From 3db1485b5b183fde68ab1f63e5ce57813109699c Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 13:02:26 +0000 Subject: [PATCH 001/107] Port the Julia backend experiment to main [skip ci] Carries the prototype of #10 (Julia sources, JuliaCall adapter, bootstrap) onto the current seam: no schema number (a source digest checked at load instead), set_initial's resume, the Adams engine protocol's carrier, hold, restore, observe and snapshot_nbytes, stage scalars from the driver's bundle cache, and general-leaf and carrier-frame refusals. Julia 1.13.3, with a fresh manifest. The benchmark harness takes julia arms. Co-Authored-By: Claude Opus 5.5 --- .gitignore | 3 + benchmarks/system.py | 6 + benchmarks/track.py | 2 +- benchmarks/worker.py | 37 +- hatch_build.py | 3 + julia/Manifest.toml | 772 ++++++++++++++++++ julia/Project.toml | 12 + julia/README.md | 273 +++++++ julia/STATUS.md | 222 ++++++ julia/bootstrap.py | 93 +++ julia/interop.py | 61 ++ julia/src/SolpropJulia.jl | 477 ++++++++++++ julia/src/adams.jl | 229 ++++++ julia/src/free.jl | 267 +++++++ julia/src/responses.jl | 320 ++++++++ julia/src/rk4.jl | 56 ++ julia/src/stages.jl | 50 ++ julia/test/runtests.jl | 101 +++ src/solprop/backends/julia/__init__.py | 9 + src/solprop/backends/julia/_backend.py | 865 +++++++++++++++++++++ src/solprop/backends/julia/_integrators.py | 204 +++++ src/solprop/backends/julia/_runtime.py | 175 +++++ src/solprop/backends/registry.py | 6 + src/solprop/driver/simulation.py | 8 +- uv.lock | 87 ++- 25 files changed, 4326 insertions(+), 12 deletions(-) create mode 100644 julia/Manifest.toml create mode 100644 julia/Project.toml create mode 100644 julia/README.md create mode 100644 julia/STATUS.md create mode 100644 julia/bootstrap.py create mode 100644 julia/interop.py create mode 100644 julia/src/SolpropJulia.jl create mode 100644 julia/src/adams.jl create mode 100644 julia/src/free.jl create mode 100644 julia/src/responses.jl create mode 100644 julia/src/rk4.jl create mode 100644 julia/src/stages.jl create mode 100644 julia/test/runtests.jl create mode 100644 src/solprop/backends/julia/__init__.py create mode 100644 src/solprop/backends/julia/_backend.py create mode 100644 src/solprop/backends/julia/_integrators.py create mode 100644 src/solprop/backends/julia/_runtime.py diff --git a/.gitignore b/.gitignore index 41cac8745..acb3c758d 100644 --- a/.gitignore +++ b/.gitignore @@ -50,3 +50,6 @@ docs/introduction/lessons/searchindex .benchmarks/ *.profraw *.profdata +.julia-runtime/ +.julia-depot/ +julia/LocalPreferences.toml diff --git a/benchmarks/system.py b/benchmarks/system.py index 2d28b28f3..13f7388ca 100644 --- a/benchmarks/system.py +++ b/benchmarks/system.py @@ -54,6 +54,9 @@ "SOLPROP_NATIVE_RAMAN_FFT_THREADS", "SOLPROP_NATIVE_RAMAN_TAIL_FFT_THREADS", "SOLPROP_NATIVE_THREADED_FFT_MIN_SAMPLES", + "SOLPROP_JULIA_THREADS", + "SOLPROP_JULIA_FFT_THREADS", + "SOLPROP_JULIA_BLAS_THREADS", "SOLPROP_BLAS_THREADS", "OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", @@ -279,6 +282,7 @@ def thread_environment( for key in ( "SOLPROP_THREADS", "SOLPROP_NATIVE_THREADS", + "SOLPROP_JULIA_THREADS", "OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", @@ -292,6 +296,8 @@ def thread_environment( "SOLPROP_NATIVE_FFT_THREADS", "SOLPROP_NATIVE_RAMAN_FFT_THREADS", "SOLPROP_NATIVE_RAMAN_TAIL_FFT_THREADS", + "SOLPROP_JULIA_FFT_THREADS", + "SOLPROP_JULIA_BLAS_THREADS", "SOLPROP_BLAS_THREADS", ): environment[key] = "1" diff --git a/benchmarks/track.py b/benchmarks/track.py index a41a64721..eaa79601c 100644 --- a/benchmarks/track.py +++ b/benchmarks/track.py @@ -36,7 +36,7 @@ thread_environment, ) -BACKENDS = ("numpy_ref", "native", "mlx") +BACKENDS = ("numpy_ref", "native", "mlx", "julia") """The backends a benchmark can name; ``mlx`` only on an Apple GPU.""" REPEAT_TOLERANCE = 1e-9 diff --git a/benchmarks/worker.py b/benchmarks/worker.py index d4eabf818..66894ffe9 100644 --- a/benchmarks/worker.py +++ b/benchmarks/worker.py @@ -19,6 +19,7 @@ import importlib import importlib.metadata import logging +import os import sys import time import traceback @@ -60,8 +61,25 @@ def emit(kind: str, **values: object) -> None: - """Flush a protocol event; the parent reads it after the worker exits.""" - print(canonical({"event": kind, **values}), flush=True) + """Flush a protocol event; the parent reads it after the worker exits. + + An embedded runtime can leave the inherited pipe nonblocking (Julia's libuv + does), and a large event then stops short; it is written in blocking mode. + """ + descriptor = None + blocking = True + try: + descriptor = sys.stdout.fileno() + blocking = os.get_blocking(descriptor) + except OSError, ValueError: + pass # In-memory output capture has no operating-system descriptor. + if descriptor is not None and not blocking: + os.set_blocking(descriptor, True) + try: + print(canonical({"event": kind, **values}), flush=True) + finally: + if descriptor is not None and not blocking: + os.set_blocking(descriptor, False) HOST_SPACES = ("OpenMP", "Threads", "Serial") @@ -75,8 +93,15 @@ def runtime(backend: str, device: bool = False) -> Record: other run needs a CPU build. """ info: Record = {} - if device and backend != "native": - raise SuiteError("only the native backend runs on a device") + if device and backend not in {"native", "julia"}: + raise SuiteError("only the native and julia backends run on a device") + if backend == "julia": + # The Julia experiment runs on its CUDA device under --device; its sources + # are identified by digest, as a native build is by its extension's. + os.environ["SOLPROP_JULIA_DEVICE"] = "cuda" if device else "cpu" + from solprop.backends.julia import source_digest # noqa: PLC0415 + + info["julia_build"] = source_digest() if backend == "native": # solprop_native must be imported before any other OpenMP runtime. import solprop_native # noqa: PLC0415 # pyright: ignore[reportMissingImports] @@ -96,7 +121,7 @@ def runtime(backend: str, device: bool = False) -> Record: import solprop # noqa: PLC0415 packages = {} - for name in ("solprop", "numpy", "scipy", "optmat", "mlx"): + for name in ("solprop", "numpy", "scipy", "optmat", "mlx", "juliacall"): try: packages[name] = importlib.metadata.version(name) except importlib.metadata.PackageNotFoundError: @@ -232,7 +257,7 @@ def timed_run( def _device_free(configuration: Record) -> int | None: """Read the accelerator's free bytes on a device run, else ``None``.""" - if not configuration.get("device"): + if not configuration.get("device") or configuration["backend"] != "native": return None import solprop_native # noqa: PLC0415 # pyright: ignore[reportMissingImports] diff --git a/hatch_build.py b/hatch_build.py index 41ae6715a..44d6cdc55 100644 --- a/hatch_build.py +++ b/hatch_build.py @@ -72,3 +72,6 @@ def update(self, metadata: dict[str, Any]) -> None: # raised only with the GPU lane and the arithmetic probes run (Q9). apple_silicon = 'sys_platform == "darwin" and platform_machine == "arm64"' extras["mlx"] = [f"mlx>=0.32.4,<0.33; {apple_silicon}"] + # The Julia backend experiment, through JuliaCall; its Julia packages are + # pinned by julia/Manifest.toml. + extras["julia"] = ["juliacall==0.9.37"] diff --git a/julia/Manifest.toml b/julia/Manifest.toml new file mode 100644 index 000000000..cf1eae287 --- /dev/null +++ b/julia/Manifest.toml @@ -0,0 +1,772 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "47a61e1134d91d5abf69dc007c90be5b71a4f8fb" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CondaPkg]] +deps = ["FileWatching", "JSON", "Markdown", "MicroMamba", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "5105aafa8fedef75ad7f44d7dbf85a1b7196e406" +registries = "General" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.38" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + + [deps.LLVM.weakdeps] + BFloat16s = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +registries = "General" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "b079a6affebde167dad8ffe0d670b53917fbcb68" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "2.0.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Preferences", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "00d3a883b716a8482da76d08dae1f6084bbfeb23" +registries = "General" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.37" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "6aaddfdf3040d02a5b3e10c6cd0e4e1dce27f23c" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+1" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SolpropJulia]] +deps = ["AcceleratedKernels", "FFTW", "KernelAbstractions", "LinearAlgebra", "PythonCall"] +path = "." +uuid = "bc9db228-6fd1-46b1-b175-748485922872" +version = "0.0.0" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +registries = "General" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +registries = "General" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "56c56fede8f01e1be7e2fdf1eb911487640619a0" +registries = "General" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.76.2+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/Project.toml b/julia/Project.toml new file mode 100644 index 000000000..d16dfc01f --- /dev/null +++ b/julia/Project.toml @@ -0,0 +1,12 @@ +name = "SolpropJulia" +uuid = "bc9db228-6fd1-46b1-b175-748485922872" + +[deps] +AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + +[compat] +julia = "1.13" diff --git a/julia/README.md b/julia/README.md new file mode 100644 index 000000000..402e202e9 --- /dev/null +++ b/julia/README.md @@ -0,0 +1,273 @@ +# Experimental Julia backend + +**Experiment — draft for collaboration, not for merge. No CI qualification.** +Start with the [status, measured results and next-work list](STATUS.md). This branch +now targets schema 35 after merging the native CPU optimisation branch and its +SEP 34 medium-flux dependency. Spatial statistics use the shared flux implementation; +the Julia numerical kernels are unchanged. + +This source-only CPU prototype implements solprop schema 35 behind +`backend="julia"`. It is an isolated experiment, authorised before a production SEP. +It preserves automatic backend selection and Python frontend signatures. The +[manual](../docs/guide/performance/julia.md) describes the supported cases and example. + +## Prepare a checkout + +Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and Git first. +Use this branch's source checkout, not a released solprop wheel. On Apple Silicon +or Linux x86_64: + +```sh +git clone --branch feature/julia-backend-prototype https://github.com/LupoLab/solprop.git solprop-julia +cd solprop-julia +uv sync --python 3.14 --extra julia +uv run --no-sync python julia/bootstrap.py +SOLPROP_JULIA_THREADS=1 uv run --no-sync python julia/example.py +SOLPROP_JULIA_THREADS=4 uv run --no-sync python julia/example.py +``` + +For an existing checkout, start at `uv sync`. Native is optional and is not needed +for these example runs. Bootstrap needs network access and several GB of disk +space for the runtime, packages and compilation caches; the first propagation can +spend substantially longer compiling than later windows spend propagating. The +example is a short four-mode Kerr capillary, ending at 0.1 mm, and prints a completion +message. It keeps output in memory. More geometries are shown in the manual. + +The bootstrap downloads the official Julia 1.13.2 archive, verifies its SHA256 against +the digest published in Julia's +[release manifest](https://julialang-s3.julialang.org/bin/versions.json), and installs +it in ignored `.julia-runtime/`. Packages and caches live in ignored `.julia-depot/`. +It never uses the user's Julia executable, startup file or global environment. +`Project.toml` records direct dependencies; `Manifest.toml` is generated by Julia Pkg. +JuliaCall and PythonCall are pinned together to 0.9.37 for this experiment. +The loader refuses an unprepared checkout and never downloads on import. + +After setup, use `uv run --no-sync` for experiments so optional installed packages +are retained. A plain `uv sync` can remove JuliaCall or a separately installed +native build. Do not import `juliacall` before solprop constructs the backend; +start a fresh Python process when changing runtime, thread or provider settings. +Unset conflicting `PYTHON_JULIACALL_*` or `JULIA_*` overrides if the loader names one. +If the archive checksum fails, remove only the named archive from `.julia-runtime/` +and retry bootstrap; do not bypass verification. Runtime cleanup is confined to +this checkout's `.julia-runtime/` and `.julia-depot/` directories. + +## Start a small Julia/native comparison + +First install the compiler and FFTW prerequisites from the +[native build guide](../docs/guide/performance/building-native.md). Then: + +```sh +uv sync --python 3.14 --extra julia --extra native +PYTHONPATH=. uv run --no-sync python julia/core_compare.py \ + --arms julia/arms-cpu.json --widths 1 4 --rounds 3 --repeats 2 \ + --case rdw:fixed-rk --output .benchmarks/julia-native-rdw +``` + +This is one bounded ten-step case, with one warm-up and six warm samples per +backend/width. Choose a new output directory each time. `arms-cpu.json` uses the +current interpreter's native build and the default Julia BLAS provider with FFTW; +Julia BLAS is explicitly serial, while native keeps the harness's budget policy. +These are controlled configurations, not an assertion that every library uses the +same actual worker count. Inspect `samples.json` and each worker's provenance. +For the optimised Apple Silicon native comparison, follow the +[NEON FFTW build instructions](../docs/guide/performance/building-native.md) and +verify the loaded FFTW/OpenMP paths. A native build using the older Homebrew FFTW +library does not include the codelet improvement measured in the updated ledger. +`differences.json` compares retained final fields; it is not a pass/fail accuracy +certificate. No Numba arm is included in this starter comparison. + +Add `--case ctc:fixed-rk` or `--case radial_filament_256:fixed-rk` when ready. +The large Cartesian cases need much more memory and time; start small. Read +[the ledger](../docs/dev/benchmarks.md#experimental-julia-cpu-prototype) before +comparing timings across machines, providers or observation policies. The tools +below also retain earlier development experiments for reproducibility. + +## Check and measure + +```sh +uv run --no-sync python julia/interop.py +SOLPROP_JULIA_THREADS=4 uv run --no-sync python julia/interop.py +uv run --no-sync pytest tests/backends/test_julia.py +JULIA_DEPOT_PATH="$PWD/.julia-depot" JULIA_LOAD_PATH='@:@stdlib' \ + JULIA_CONDAPKG_BACKEND=Null JULIA_PYTHONCALL_EXE="$PWD/.venv/bin/python" \ + .julia-runtime/julia-1.13.2/bin/julia --startup-file=no --threads=4 \ + --project=julia julia/test/runtests.jl +uv run --no-sync python julia/benchmark.py +``` + +The benchmark runs separate processes at 1, 2, 4 and the physical-core limit, without +duplicate widths. Each of three rounds alternates backend order and takes five warm +repeats. Both backends use FFTW `ESTIMATE`, identical thread limits, FSAL, four or +sixteen modes, and ten prescribed 10 µm steps. It reports construction and first-window +costs separately. Observation and shared host statistics have their own timer. +Generated JSON and field witnesses stay under ignored `.benchmarks/`. +Add `--mode-averaged` to `benchmark.py` or `compare.py` to measure the same pulse and +ten-step window using one amplitude and one effective-area nonlinear node. For a +three-backend Mac comparison: + +```sh +uv run --no-sync python julia/compare.py --mode-averaged --blas-threads 1 \ + --arms numba_cpu native julia-accelerate-fftw --output .benchmarks/mode-averaged +``` + +Use `--radial` instead to compare 64- and 256-node axisymmetric Kerr beams at +0.9 critical power in constant argon. Both use the same ten prescribed 10 µm steps, +one or four numerical/FFT threads, and the declared BLAS width. Radial spatial +statistics have their own timer, separate from propagation. The shared Julia +matrix pipeline consumes the translated Hankel maps and the shared spatial-loss +matrix; no new transform package is required. + +Use `--cartesian` for 32×32 and 64×64 Cartesian grids spanning ±500 µm, with the +same pulse, material, time grid and prescribed steps as the radial cases. This path +uses FFTs rather than BLAS contractions. The seam's compact separable operator is +evaluated per stage; a single forward/inverse pair replaces cached stage volumes. +The default spatial statistics are timed separately. On Linux compare +`numba_cpu native julia-openblas-fftw julia-mkl-mkl` to distinguish FFT providers; +changing BLAS alone cannot accelerate this Cartesian propagation path. Add +`--sizes 256` to compare a larger transverse grid at the same time resolution. +Worker records include explicitly owned bytes and peak process resident memory; +the latter also includes frontend arrays, library workspace and temporary copies. + +`--worker julia --profile` additionally writes a Julia sampling profile; provide an +existing output directory and an output JSON path when running a worker directly. + +The numerical core uses native Julia arrays, planned FFTW transforms and BLAS `mul!`. +AcceleratedKernels supplies task scheduling and the generic loop implementation over +KernelAbstractions. A small CPU Kerr traversal shares the scalar product with the +generic loop, but visits contiguous time columns to avoid costly index division. +Constant-table stage propagators are cached for exactly equal step lengths and +rebuilt when an adaptive trial changes the step. CPU pointwise loops traverse +contiguous columns, use SIMD, and require at least 32768 samples per task. +No umbrella fast-math or reassociation of protected reductions is enabled. + +The modal FFT cap is `SOLPROP_FFTW_THREADS`. Raman convolution and transverse +plans accept independent `SOLPROP_JULIA_RAMAN_FFT_THREADS` and +`SOLPROP_TRANSVERSE_FFTW_THREADS` limits. Modal and doubled-grid Raman plans +default to serial below 16384 real-side samples, otherwise up to four workers; +the transverse default follows the modal cap. Mode-averaged BLAS defaults to one +worker. Explicit overrides remain available. Plan widths are +recorded in backend metadata. The kernel-construction FFT is serial and outside +the measured propagation window. + + +`SOLPROP_FFTW_PLAN=estimate|measure|patient` selects Julia's planning effort; +`estimate` remains the experimental default. Measured plans spend additional time +at construction choosing algorithms for the actual array layout and thread count. +Planning is excluded from warm propagation timings and recorded separately. +`julia/compare.py --plan measure` applies the same request to all compared backends. +No FFTW wisdom is imported by this experimental Julia adapter. + +GPU execution is not implemented or qualified. CUDA/AMDGPU array allocation, FFT plans, +device-safe reductions and synchronization still need adapters and device tests; +the presence of KernelAbstractions/GPUArraysCore in the dependency graph does not +establish GPU support. Metal, Float32, runtime distribution and compilation-cache +engineering remain future work. + +## Provider and compiler experiments + +`SOLPROP_JULIA_BLAS=openblas|accelerate|mkl` selects BLAS before constructing the +first backend. AppleAccelerate is the macOS default; other prepared platforms +default to OpenBLAS. AppleAccelerate requires macOS; +MKL is qualified here only on Linux x86_64. Accelerate's threading API selects +single-threaded or library-managed parallel execution, not an exact worker count. +For controlled comparisons set `SOLPROP_BLAS_THREADS=1`. The comparison runner +sets MKL's global and FFT limits to the requested numerical width and its BLAS +domain separately, so `--blas-threads 1` does not cap MKL FFT execution. See +[Intel's domain thread controls](https://www.intel.com/content/www/us/en/docs/onemkl/developer-guide-windows/2025-0/mkl-domain-num-threads.html). + +FFTs remain FFTW independently of BLAS. AppleAccelerate 0.7 also extends AbstractFFTs; +the engine deliberately plans from strided views to retain FFTW plans. To experiment +with MKL FFTs in an isolated checkout, call `FFTW.set_provider!("mkl")` with the private +runtime and project, then restart Python. Restore with `FFTW.set_provider!("fftw")`. +The preference belongs only to that checkout and is not committed. +MKL's FFTW compatibility layer ignores FFTW planning-rigor flags; a recorded +`measure` request is not evidence that MKL performed FFTW's measured search. +See [Intel's FFTW wrapper documentation](https://www.intel.com/content/www/us/en/docs/onemkl/developer-reference-c/2024-1/using-fftw3-wrappers.html). + +`julia/tune.py --compare-blas accelerate --modes 16 --output .benchmarks/blas.json` +alternates providers and Numba in one process after warming. On Linux use +`--compare-blas mkl`. Explicitly set the Julia, Numba, FFT and BLAS thread limits +before launching. `--baseline PATH` also loads a saved numerical module for an +alternating before/after comparison. The runner records source digest, thread +settings, raw timings, source counts and numerical differences, and rejects a +failed rounding screen. It does not establish adaptive accuracy by timing alone. + +The measured compiler settings remain native CPU targeting, normal inlining, `-O2`, +and automatic bounds checking with local `@inbounds` in validated kernels. An +alternating `-O3` experiment did not improve the declared case. LLVM output confirms +packed double-precision SIMD arithmetic in the Kerr loop; protected error reductions +retain their ordered arithmetic. See the benchmark ledger for measured effects. + +The optional `--numba-tabulate` arm checks Numba's tabulated-propagator setting +against its default. On Linux, a mixed Julia/MKL and Numba process can interact with +OpenMP affinity. Use fresh backend processes (`benchmark.py --worker ...`) and +unset `OMP_PLACES` and set `OMP_PROC_BIND=false` for the final comparison; restrict +both processes to the same CPU set externally. Same-process provider sweeps are +useful pilots, but do not replace this isolation check. + +Provider interfaces: [AppleAccelerate](https://github.com/JuliaLinearAlgebra/AppleAccelerate.jl), +[MKL.jl](https://github.com/JuliaLinearAlgebra/MKL.jl), and +[FFTW's provider preference](https://juliamath.github.io/FFTW.jl/stable/). + +For a fresh-process comparison with native and provider attribution, build native in +this checkout, then run: + +```sh +uv sync --extra native --extra julia +uv run --no-sync python julia/compare.py --blas-threads 1 --output .benchmarks/mac-providers +# Linux: native uses the providers chosen at build time. +uv run --no-sync python julia/compare.py --arms numba_cpu native \ + julia-openblas-fftw julia-mkl-fftw julia-mkl-mkl --output .benchmarks/linux-providers +``` + +The runner alternates three rounds of five warm windows per arm, at one and four +threads. It records native build information, actual loaded thread pools, NumPy's +BLAS configuration, source counts and final-field witnesses. On macOS both the +installed NumPy/SciPy and native build may already use Accelerate; inspect their +records rather than assuming Numba uses OpenBLAS. `benchmark.py --worker native +--propagator-mode tabulate` records the requested policy, but source inspection +shows that native's resident DOPRI5 path still forms its flows per stage; the +native low-storage integrator has the distinct table option. Removing `SOLPROP_NATIVE_KERNEL_THREADS` and `SOLPROP_NATIVE_FFT_THREADS` +while keeping its global cap exercises native's automatic operation sizing. + +## SEP 30 core cases + +The scalar CPU subset includes one field-plasma channel, constant scalar Raman, +longitudinal stage expansions and resident exponential Adams. Cartesian envelopes +also execute the existing prescribed RK4IP scheme. Run the frozen core definitions +through the standard harness, including its declared output/statistics windows: + +```sh +uv run --no-sync python -m benchmarks list --set core --backend julia +uv run --no-sync python -m benchmarks run --set core --backend julia --mode quick +uv run --no-sync python -m benchmarks run --set core --backend julia --track fixed-rk +``` + +Use the ordinary machine-profile and reference qualification process for publishable +standard comparisons. `core_screen.py` is an additional development tool: it times +propagation only, saves final fields/statistics, and records setup and first-call costs. +Its adaptive timings exclude the standard harness's observations. The focused checks +are in `tests/backends/test_julia_core.py`. Unsupported geometries, response combinations +and integrator variants fail explicitly; see the manual for the scope. + +Cartesian and line field grids also support one scalar plasma channel, including +accepted-field population diagnostics. Their current is evaluated in physical-space +chunks before the transverse forward FFT. Focused source, short DOPRI/RK4IP, +absorber, chunk-tail and memory checks are in +`tests/backends/test_julia_cartesian_plasma.py`. The retained strided FFT layout +uses parallel large copies and inverse normalization, a protected real-root branch, +and omits additive absorber transforms only when their rates are exactly zero. +`tests/backends/test_julia_zero_absorber.py` checks both inactive and active losses. +Exactly zero plasma-rate columns without initial electrons omit current integration +and clear reused outputs. `tests/backends/test_julia_zero_plasma.py` checks reuse +after an ionising source and retention of pre-existing electrons. +Modal and radial sources also skip additive transforms for exactly absent loss +rates; `tests/backends/test_julia_modal_zero_absorber.py` checks active and absent +losses under both temporal schemes. + +The mode-averaged envelope extension executes `gnlse_soliton` and +`gnlse_raman_shock`, using the existing frontend and translated Kerr/Raman/shock +coefficients. Both DOPRI and Adams share the scalar engine. The corresponding +short source, propagation, absorber and reset checks are in +`tests/backends/test_julia_envelope.py`. The long-pulse hydrogen and argon +blueshift mode-averaged field cases use the already supported plasma/Raman path. diff --git a/julia/STATUS.md b/julia/STATUS.md new file mode 100644 index 000000000..4a1e5fe84 --- /dev/null +++ b/julia/STATUS.md @@ -0,0 +1,222 @@ +# Julia experiment: status and handoff + +**Draft experiment — do not merge. CPU only. No CI qualification.** + +This branch demonstrates that Julia can own solprop's numerical backend while the +Python frontend, translation, shared controller and output system remain in use. +It is useful for trying cases, reproducing short timings and continuing development. +It is not ready for production integration or a claim of complete backend parity. +The experiment started from `1df3e4117d7f`, with kernel schema 34. The native CPU +optimisation branch at `75d4fe1` is now merged, including its schema-35 medium-flux +dependency. The adapter passes the new flux plan to shared spatial statistics; +Julia numerical kernels remain unchanged. Qualification of additional medium-flux +capabilities beyond the existing constant-medium spatial cases remains future work. + +Start with the [installation and runnable example](README.md#prepare-a-checkout), +then the [small Julia/native comparison](README.md#start-a-small-julianative-comparison). +The [manual](../docs/guide/performance/julia.md) describes the numerical and thread +contracts. The [benchmark ledger](../docs/dev/benchmarks.md#experimental-julia-cpu-prototype) +contains the measured windows, providers, spreads, correctness evidence and rejected +optimizations, including the final Mac and Xeon comparisons. + +## What works + +| Area | Implemented subset | +|---|---| +| Capillaries | Resolved and mode-averaged scalar field grids, constant radius, separable longitudinal material profiles | +| Mode-averaged envelopes | GNLSE Kerr, constant scalar Raman and translated self-steepening | +| Radial free space | Scalar fields in a constant medium, Kerr and one plasma channel | +| Cartesian and line free space | Scalar Kerr fields/envelopes and one field-plasma channel | +| Responses | Kerr with/without THG on fields; one scalar plasma channel; one constant scalar Raman component on admitted modal/radial routes | +| Integration | DOPRI5 with FSAL; resident exponential Adams on non-Cartesian routes; prescribed RK4IP on Cartesian/line routes | +| Output | Normal save planes, hard masks, both temporal-absorber schemes, default modal/spatial and supported plasma statistics | +| Platforms exercised | Apple Silicon macOS and Linux x86_64, private Julia 1.13.2, Python 3.14 | + +The admission checks explicitly refuse unsupported combinations. In particular: +GPU execution, vector polarization, batching, noise, interpolated planes, tapered +or general modal guides, Cartesian Raman/Adams, resolved/radial envelopes, +envelope plasma/harmonics, multiple plasma/Raman components and advanced +dispersive/regional responses remain outside the experiment. See the manual and +`_refuse` in `src/solprop/backends/julia/_backend.py` for the detailed boundary. +Automatic backend selection is unchanged: request `backend="julia"` explicitly. + +## Implementation size + +Physical source lines, including comments and blank lines, counted on 2026-10-24: + +| Implementation | Numerical code and bindings | Python adapter | Total | +|---|---:|---:|---:| +| Julia prototype | 1,395 | 1,322 | **2,717** | +| Native backend | 24,537 | 4,523 | **29,060** | + +The prototype is approximately **10.7 times smaller by this measure** (90.7% fewer +lines). Julia's numerical column is the six `julia/src/*.jl` files. Native's is all +`.cpp`/`.hpp` under `native/src/` and `native/include/`, except `benchmark_gemm.cpp` +and `coverage_labels.cpp`, plus the `_core.pyi` binding declaration. Python +columns count `src/solprop/backends/julia/*.py` and +`native/src/solprop_native/*.py`, respectively. Tests, documentation, build files, +benchmarks and external dependencies are excluded from both totals. + +This is an implementation-footprint comparison, **not equivalent feature coverage**. +Native has a much larger capability matrix and CPU/CUDA/HIP implementations. Julia +also uses compact formatting, including multiple statements on some lines. Both +reuse solprop's Python frontend and shared driver, and both rely on numerical +libraries. A future matched-capability comparison and readability review would be +more informative than treating this ratio as a language productivity benchmark. + +## Updated Mac comparison after native CPU optimisation + +The native comparison now includes `75d4fe1`, its NEON FFTW build and the shared +schema-35 frontend. Julia numerical kernels are unchanged. The default native LOCAL +compiler policies are retained; library paths and per-operation thread counts were +verified. Six warmed ten-step samples per cell, from three alternating rounds, +give the following propagation medians in seconds: + +| Case | Native, 1 | Julia, 1 | Native, 18 | Julia, 18 | +|---|---:|---:|---:|---:| +| RDW | 0.114971 | 0.162999 | 0.062194 | 0.070273 | +| CtC | 3.781297 | 5.625456 | 2.334840 | 2.201848 | +| Radial filament, 256 nodes | 0.617973 | 0.824063 | 0.299448 | 0.928311 | +| Averaged helium RDW | 0.009504 | 0.017540 | 0.009555 | 0.017701 | +| Resolved argon blueshift | 0.054960 | 0.052243 | 0.020362 | 0.019921 | +| Hydrogen Raman, 6 ps | 0.610981 | 1.105845 | 0.181659 | 0.446256 | +| GNLSE soliton | 0.004863 | 0.006598 | 0.004938 | 0.006619 | +| Averaged argon blueshift | 0.004750 | 0.005199 | 0.004775 | 0.005247 | +| Cartesian 192² × 300 | 8.021165 | 16.110929 | 1.160111 | 2.001772 | +| Cartesian 384² × 600 | 78.224075 | 78.842053 | 10.860181 | 12.629519 | + +Native has taken the serial CtC and H₂ wins, and wins most of the measured cases. +Julia retains the parallel CtC and modest resolved-argon leads. Serial 384² is +effectively tied. Native's lower parallel 384² median has a wide paired range, +including one round where Julia was slightly faster, so its advantage is unresolved +at fine resolution. Host contention interrupted one large-case round; it was +excluded and restarted. Residual host activity remains disclosed in the +[updated ledger](../docs/dev/benchmarks.md#julianative-comparison-after-native-cpu-optimisation), +along with provider/thread settings, spreads, the helper-library audit and separate +setup/observation costs. No fresh Xeon comparison is claimed here. + +## Historical performance before native CPU optimisation + + +Julia is competitive on several realistic CPU cases, but it is not universally +faster than native. The earlier Mac round used an Apple M5 Max with 18 physical cores +and 128 GiB, **native's default Mac build settings**, and Julia with Accelerate +BLAS and FFTW. These are median seconds for ten prescribed steps, six warm samples +per cell from three alternating rounds. Setup, compilation and final observations +are outside these propagation timers; first-window/setup costs were recorded +separately. DOPRI cases use 61 source evaluations; Cartesian RK4IP uses 40. + +| Case | Native 1 thread | Julia 1 thread | Native 18-thread budget | Julia 18-thread budget | +|---|---:|---:|---:|---:| +| RDW | 0.128269 | 0.157036 | 0.070999 | 0.068320 | +| CtC | 6.288408 | 5.325555 | 2.685244 | 2.107181 | +| Radial filament, 256 nodes | 0.649903 | 0.794537 | 0.288600 | 0.855188 | +| Averaged helium RDW | 0.010500 | 0.017543 | 0.010590 | 0.017662 | +| Resolved argon blueshift | 0.056584 | 0.050703 | 0.022913 | 0.019836 | +| Hydrogen Raman, 6 ps | 1.194044 | 1.051791 | 0.243912 | 0.437328 | +| GNLSE soliton | 0.005278 | 0.006534 | 0.005524 | 0.006570 | +| Averaged argon blueshift | 0.005019 | 0.005053 | 0.005156 | 0.005084 | +| Cartesian 192² × 300 | 9.334232 | 15.488092 | 1.217616 | 1.764022 | +| Cartesian 384² × 600 | 89.175180 | 77.226190 | 10.626641 | 11.544229 | + +Julia is 1.27× faster for parallel CtC, 1.15× for parallel resolved argon, and +1.15× for serial large Cartesian propagation. The large Cartesian parallel result +is 8.6% slower than native. Native wins the radial and parallel long-pulse Raman +cases by substantial margins. Radial parallel timings were noisy, but their +ranges remain separated. The ledger records those ranges and the operation-level +FFT/BLAS policies; an 18-thread budget does not force every operation to use 18 +threads. Large Cartesian FFT widths were explicitly set to 18/18. + +The Xeon Gold 6240 results are less favorable: native wins every measured core +window, including the additional modal cases. The comparison explicitly included +GCC 16.2/OpenBLAS and Intel C++/MKL native builds. Neither native bundle wins +everything. On the large Cartesian cases, switching only Julia's FFT provider to +MKL reduced time by roughly 17–19%, with BLAS held fixed, but native remained ahead. +These are hardware/provider/configuration comparisons, not language-wide limits. + +The final Mac field differences were at most 1.65e-15 relative L2 for modal/radial +cases and 8.69e-16 for the large Cartesian cases, with finite fields and matching +work counts. These matched-window comparisons supplement the NumPy-oracle checks; +they do not bound every adaptive propagation's global error. The 384² owned-buffer +ledger is 11.762 GB for Julia versus 7.567 GB for native, excluding runtime, opaque +FFT storage and export temporaries. Memory reduction remains worthwhile. + +## Qualification and publication status + +Development included focused NumPy-reference source/step/short-run comparisons, +rejection/reset and observation-ownership checks, tighter adaptive references, +interop checks and standalone Julia checks. The final combined plasma/absorber +slice passed 57 focused checks on Linux. The schema-35 compatibility update passed +29 focused checks on macOS, including spatial statistics against NumPy. The ledger records earlier stages and +failed or rejected experiments; these counts are not a full-suite certificate. + +**The full Python/native gates, slow lanes and coverage qualification were not run +for this experiment. No tests or gates were run during draft-PR preparation.** +The new runnable example is the existing manual example factored into a script; +the final handoff commands have not been rerun in a fresh clone. Raw runtime caches, +large field witnesses and private campaign directories are not part of the PR. +Public evidence is in the ledger; the committed runners generate new receipts. + +This draft intentionally has no CI qualification. Keep `[skip ci]` in every new +head commit while this policy applies: GitHub uses that marker, not draft status, +to [skip `push`/`pull_request` workflows](https://docs.github.com/en/actions/how-tos/manage-workflow-runs/skip-workflow-runs). +Required checks may remain pending. The +branch's `.readthedocs.yaml` also cancels at checkout with exit code 183, before +dependency installation or documentation generation, using +[Read the Docs' cancellation mechanism](https://docs.readthedocs.com/platform/stable/guides/build/skip-or-cancel-builds.html). +Remove that cancellation and +the skip policy when proposing a reviewed integration. Repository-wide CI and +other branches are unchanged. + +## Next work + +- [ ] **Independent review and integration.** Agree an accepted SEP, review the + protected arithmetic/normalization/ownership contracts, reconcile with current + main, qualify further SEP 34 medium-flux cases, and simplify/format the compact Julia code + for maintainability before any merge proposal. +- [ ] **Reproducible qualification.** Exercise the documented fresh-clone setup on + macOS/Linux; expand NumPy-oracle, adaptive-convergence, state-lifetime and + thread-count checks. Re-enable CI and run the full gates only when integration + is proposed. Assess the shared benchmark-worker changes independently. +- [ ] **NVIDIA GPU implementation and tests.** Add CuArray allocation, device FFTs, + contractions, reductions and synchronization; remove scalar host indexing and + audit transfers across the Python boundary. Start with a small scalar Kerr + capillary, then radial/Cartesian cases; check against NumPy and native before + timing warm device windows, transfers and memory. KernelAbstractions and + AcceleratedKernels dependencies alone do not make this a GPU backend. +- [ ] **AMD GPU implementation and tests.** Add ROCArray/AMDGPU FFT and contraction + support, then repeat the same correctness and bounded performance qualification + on actual hardware. Preserve the common scalar operations where practical. +- [ ] **Operation-sized CPU policies.** Profile radial high-thread regressions and + parallel Raman, including the native Accelerate path. Measure FFTW planning, + layout, task sizes and MKL/OpenBLAS/Accelerate separately. Retain baselines and + stop tuning when repeatable gains disappear; do not enable umbrella fast-math. +- [ ] **Memory and startup.** Reduce large Cartesian resident volumes and copies; + measure allocations, peak RSS and host-statistics/export costs as well as warm + propagation. Investigate Julia precompilation/cache reuse and cold-start cost. +- [ ] **Capability extensions.** Prioritize Cartesian Raman/Adams, resolved/radial + envelopes and envelope plasma, then mixtures/multiple responses, polarization, + batching, noise, tapered/general geometries and interpolated output as needed. + Add each capability with a small reference comparison and a ten-step A/B case. +- [ ] **Distribution.** Design runtime discovery/installation, platform support and + packaging instead of relying on a source-tree-relative private Julia runtime. + Keep explicit failure for unsupported features and preserve automatic selection. +- [ ] **Later precision work.** Establish Float32 error budgets before Metal or other + single-precision GPU work. CPU Float64 measurements do not qualify that path. + +## Code map + +| Path | Role | +|---|---| +| `julia/src/SolpropJulia.jl` | Typed engine, modal/radial pipeline, transforms, Kerr, DOPRI and state lifecycle | +| `julia/src/responses.jl` | Translated plasma/Raman operations and population diagnostics | +| `julia/src/stages.jl`, `adams.jl` | Stage expansions and resident exponential Adams | +| `julia/src/free.jl`, `rk4.jl` | Cartesian/line transforms and prescribed RK4IP | +| `src/solprop/backends/julia/` | Private runtime, schema admission, shared-driver hooks, memory and observations | +| `julia/Project.toml`, `Manifest.toml`, `bootstrap.py` | Dependencies and checksummed private runtime setup | +| `julia/core_compare.py`, `core_profile.py` | Lightweight standard-case comparisons and profiling | +| `tests/backends/test_julia*.py`, `julia/test/` | Existing focused checks for future contributors to run | + +No native numerical source was changed by the experiment. CPU tuning retained +measured improvements and rejected slower layout/fusion candidates rather than +shipping them as defaults. diff --git a/julia/bootstrap.py b/julia/bootstrap.py new file mode 100644 index 000000000..bcd3bb64a --- /dev/null +++ b/julia/bootstrap.py @@ -0,0 +1,93 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Prepare the experiment's Julia runtime and instantiate its committed manifest. + +``SOLPROP_JULIA_EXE`` names an existing Julia 1.13 (for example juliaup's); without +it the checksummed official release is downloaded into ``.julia-runtime/``. The +packages go to ``SOLPROP_JULIA_DEPOT``, by default ``.julia-depot/``. +""" + +import hashlib +import os +import platform +import subprocess +import sys +import tarfile +import urllib.request +from pathlib import Path + +VERSION = "1.13.3" +# Digests published by Julia's official versions.json for these release archives. +RELEASES = { + ("darwin", "arm64"): ( + "mac/aarch64", + "macaarch64", + "b9f0e8450fbcb392aa3e8b43fa1fc09993665a31bf705d7ef8084f0ac4ad3765", + ), + ("linux", "x86_64"): ( + "linux/x64", + "linux-x86_64", + "5c61cb4b40332cb5a3504e7779e2f5dac093caa4a1116ded19f01413f85c63e4", + ), + ("linux", "aarch64"): ( + "linux/aarch64", + "linux-aarch64", + "9ceb053bee6dfb8189bd40afd6925de3a9b7ff8fac8d01a5fcdd84af171ddf03", + ), +} +ROOT = Path(__file__).resolve().parents[1] + + +def executable() -> Path: + """Return the Julia executable, downloading the checksummed release if needed.""" + if named := os.environ.get("SOLPROP_JULIA_EXE"): + return Path(named) + release = RELEASES.get((sys.platform, platform.machine())) + if release is None: + raise RuntimeError("no Julia release is recorded for this platform") + directory, suffix, expected = release + private = ROOT / ".julia-runtime" + binary = private / f"julia-{VERSION}/bin/julia" + if binary.is_file(): + return binary + private.mkdir(exist_ok=True) + name = f"julia-{VERSION}-{suffix}.tar.gz" + archive = private / name + if not archive.is_file(): + url = f"https://julialang-s3.julialang.org/bin/{directory}/1.13/{name}" + urllib.request.urlretrieve(url, archive) # noqa: S310 - fixed https URL + with archive.open("rb") as stream: + if hashlib.file_digest(stream, "sha256").hexdigest() != expected: + raise RuntimeError("Julia archive SHA256 does not match the release") + with tarfile.open(archive) as bundle: + bundle.extractall(private, filter="data") + return binary + + +def main() -> None: + """Instantiate and precompile the Julia project.""" + env = os.environ | { + "JULIA_DEPOT_PATH": os.environ.get( + "SOLPROP_JULIA_DEPOT", str(ROOT / ".julia-depot") + ), + "JULIA_LOAD_PATH": "@:@stdlib", + "JULIA_CONDAPKG_BACKEND": "Null", + "JULIA_PYTHONCALL_EXE": sys.executable, + } + subprocess.run( + [ + str(executable()), + "--startup-file=no", + f"--project={ROOT / 'julia'}", + "-e", + "using Pkg; Pkg.instantiate(); Pkg.precompile()", + ], + env=env, + check=True, + ) + sys.stdout.write(f"Prepared Julia and julia/Manifest.toml\n") + + +if __name__ == "__main__": + main() diff --git a/julia/interop.py b/julia/interop.py new file mode 100644 index 000000000..0ee05b4bc --- /dev/null +++ b/julia/interop.py @@ -0,0 +1,61 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Exercise the private bridge in a fresh process before numerical qualification.""" + +import gc +import os + +import numpy as np + +from solprop.backends.julia._runtime import call_julia, runtime +from solprop.exceptions import BackendError + + +def main() -> None: + """Check no-GIL threads, owning complex transfers, FFTs and exception causes.""" + runtime() + import juliacall # noqa: PLC0415 - after the isolated runtime is configured + + module = juliacall.newmodule("InteropSmoke") + module.seval(""" + using FFTW, AcceleratedKernels + own(x) = Matrix{ComplexF64}(x) + function threaded(x) + y = similar(x) + AcceleratedKernels.foreachindex(x; max_tasks=Threads.nthreads()) do i + y[i] = 2x[i] + end + y + end + function roundtrip(x) + y = plan_fft(view(x,:,:),1)*x + plan_ifft(view(y,:,:),1)*y + end + fail() = throw(ArgumentError("intentional bridge smoke test")) + """) + original = np.arange(24).reshape(6, 4).astype(complex) * (1 + 0.5j) + owned = module.own(original) + expected = original.copy() + original[:] = 0 + gc.collect() + module.seval("GC.gc()") + np.testing.assert_array_equal(np.asarray(owned), expected) + np.testing.assert_array_equal( + np.asarray(call_julia(module.threaded, owned, nogil=True)), 2 * expected + ) + transformed = np.asarray(call_julia(module.roundtrip, owned, nogil=True)) + # Two length-six transforms: normwise backward error scales with log N. + bound = 32 * np.finfo(float).eps * np.log2(6) * np.linalg.norm(expected) + assert np.linalg.norm(transformed - expected) <= bound + try: + call_julia(module.fail) + except BackendError as error: + assert error.__cause__ is not None and "intentional" in str(error) + else: + raise AssertionError("Julia exception was not translated") + assert os.environ["PYTHON_JULIACALL_HANDLE_SIGNALS"] == "yes" + + +if __name__ == "__main__": + main() diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl new file mode 100644 index 000000000..8194709b0 --- /dev/null +++ b/julia/src/SolpropJulia.jl @@ -0,0 +1,477 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The Julia backend experiment's engine. All arrays behind the bridge are owned.""" +module SolpropJulia +using LinearAlgebra +using FFTW +using PythonCall +import AcceleratedKernels as AK + +# The digest of the sources this module was loaded from, set by the Python loader. +const SOURCE_DIGEST = Ref("") +record_digest(digest) = (SOURCE_DIGEST[] = String(digest); nothing) +loaded_digest() = SOURCE_DIGEST[] + +mutable struct Engine{C,W} + config::C + work::W + fsal_valid::Bool + calls::Int + propagator_dz::Float64 + factor::Float64 +end + +# These loops inline their body for one task, and use the same body on GPU arrays. +function foreach_element(f, a, tasks) + AK.foreachindex(f, a; max_tasks=tasks, min_elems=4096) +end + +# Host traversal removes the per-sample integer divide. Device arrays retain a +# flat index kernel with the same scalar body; threading needs enough work per task. +function foreach_sample(f, a, tasks) + nr = size(a,1) + foreach_element(a,tasks) do i + f(mod1(i,nr),(i-1)÷nr+1,i) + end +end +function foreach_sample(f, a::StridedMatrix, tasks) + nr = size(a,1) + AK.foreachindex(axes(a,2);max_tasks=tasks,min_elems=max(1,cld(32768,nr))) do m + @inbounds @simd for row in axes(a,1) + @inline f(row,m,row+(m-1)*nr) + end + end +end + +@inline polarization(value::Real, factor, analytic_factor) = factor*(value*value)*value +@inline polarization(value::Complex, factor, analytic_factor) = factor*analytic_factor*abs2(value)*real(value) + +function polarize!(nodes, values, c, factor=c.factor) + nt = size(nodes,1) + foreach_element(nodes,c.tasks) do i + @inbounds nodes[i] = polarization(values[i],factor,c.analytic_factor)*c.window[mod1(i,nt)] + end +end + +# The first profile was dominated by indexing the pointwise Kerr product. This +# CPU-only traversal removes integer division and exposes independent time samples +# to SIMD. The scalar arithmetic is the same as the generic device-ready body. +const HostRealMatrix = Union{Matrix{Float64},SubArray{Float64,2,Matrix{Float64}}} +function polarize_column!(nodes, values, window, factor, analytic_factor, node) + @inbounds @simd for t in axes(nodes,1) + nodes[t,node] = polarization(values[t,node],factor,analytic_factor)*window[t] + end + nothing +end + +function polarize!(nodes::HostRealMatrix, values, c, factor=c.factor) + AK.foreachindex(axes(nodes,2); max_tasks=c.tasks,min_elems=max(1,cld(32768,size(nodes,1)))) do node + polarize_column!(nodes,values,c.window,factor,c.analytic_factor,node) + end +end + +function polarize_envelope!(nodes, values, c, factor) + foreach_sample(nodes,c.tasks) do t,m,i + @inbounds nodes[i] = factor*c.analytic_factor*abs2(values[i])*values[i]*c.window[t] + end +end + +# AbstractFFTs' normalized inverse plan performs a serial lmul! after its FFT. +# Keep exactly that scale and multiplication order, distributing only independent +# samples when the measured operation is large enough to justify task launches. +fft_apply!(destination,plan,source,c)=mul!(destination,plan,source) +function fft_apply!(destination,plan::FFTW.ScaledPlan,source,c) + if !c.parallel_fft_scale || c.tasks == 1 || length(destination) < 32768 + return mul!(destination,plan,source) + end + mul!(destination,plan.p,source) + scale=plan.scale + AK.foreachindex(1:cld(length(destination),32768);max_tasks=c.tasks,min_elems=1) do block + first=32768(block-1)+1 + last=min(first+32767,length(destination)) + @inbounds @simd for i in first:last + destination[i]=scale*destination[i] + end + end + destination +end + +# AppleAccelerate extends AbstractFFTs for dense Arrays. A strided view selects +# FFTW's planner explicitly, keeping this BLAS choice separate from FFT choice. +fft_storage(a) = view(a, :, :) + +function create(input) + matrix(name, T) = Matrix{T}(input[name]) + vector(name, T) = Vector{T}(input[name]) + scalar(name, T) = convert(T, input[name]) + tasks = scalar("threads", Int) + FFTW.set_num_threads(scalar("fft_threads", Int)) + BLAS.set_num_threads(scalar("blas_threads", Int)) + plan_flag = lowercase(get(ENV,"SOLPROP_FFTW_PLAN","estimate")) + fft_flags = get(Dict("estimate"=>FFTW.ESTIMATE,"measure"=>FFTW.MEASURE,"patient"=>FFTW.PATIENT),plan_flag,nothing) + isnothing(fft_flags) && throw(ArgumentError("SOLPROP_FFTW_PLAN must be estimate, measure or patient")) + config = ( + plan_flag=plan_flag, fft_flags=fft_flags, + parallel_fft_scale=get(ENV,"SOLPROP_JULIA_PARALLEL_FFT_SCALE","1")=="1", + real_root=get(ENV,"SOLPROP_JULIA_REAL_ROOT","1")=="1", + skip_zero_plasma=get(ENV,"SOLPROP_JULIA_SKIP_ZERO_PLASMA","1")=="1", + fft_threads=scalar("fft_threads",Int), + blas_threads=scalar("blas_threads",Int), + raman_fft_threads=haskey(input,"raman_fft_threads") ? scalar("raman_fft_threads",Int) : scalar("fft_threads",Int), + transverse_fft_threads=haskey(input,"transverse_fft_threads") ? scalar("transverse_fft_threads",Int) : scalar("fft_threads",Int), + envelope=haskey(input,"envelope") && scalar("envelope",Bool), + low_storage=haskey(input,"low_storage") && scalar("low_storage",Bool), + free=haskey(input,"free") && scalar("free",Bool), + linear=matrix("linear", ComplexF64), prefactor=matrix("prefactor", ComplexF64), + synthesis=matrix("synthesis", Float64), projection=matrix("projection", Float64), + projection_coarse=matrix("projection_coarse", Float64), embedded=scalar("embedded", Bool), + spatial_absorber=haskey(input,"spatial_absorber") ? matrix("spatial_absorber",Float64) : zeros(0,0), + crop=vector("crop", Int) .+ 1, mask=vector("mask", Bool), + norm_mask=vector("norm_mask", Bool), weights=vector("weights", Float64), + window=vector("window", Float64), omega_window=vector("omega_window", Float64), + rate=vector("rate", Float64), coarse_rate=vector("coarse_rate", Float64), + a=matrix("a", Float64), b=vector("b", Float64), e=vector("e", Float64), + c=vector("c", Float64), factor=scalar("factor", Float64), + analytic=scalar("analytic", Bool), analytic_factor=scalar("analytic_factor", Float64), + split=scalar("split", Bool), rtol=scalar("rtol", Float64), atol=scalar("atol", Float64), + tasks=tasks, cache_propagators=haskey(input,"cache_propagators") ? scalar("cache_propagators",Bool) : true, + ) + config.free && return create_free(config, input) + # The translated rates are constant over a trial. An exactly absent loss + # needs no additive temporal FFT; the accepted-step split remains separate. + active_absorber = any(!iszero,config.spatial_absorber) || + (!config.split && any(!iszero,config.rate)) + config = merge(config, (modal_in_stage_absorber=( + get(ENV,"SOLPROP_JULIA_SKIP_ZERO_MODAL_ABSORBER","1") == "1" ? + active_absorber : (!config.split || !isempty(config.spatial_absorber)) + ),)) + nw, nm = size(config.linear) + nt = length(config.window) + chunk = min(scalar("chunk", Int), size(config.synthesis, 2)) + nf = config.envelope ? nt : nt ÷ 2 + 1 + T = config.envelope ? ComplexF64 : Float64 + fine = zeros(ComplexF64, nf, nm) + modal = zeros(T, nt, nm) + nodes = zeros(T, nt, chunk) + analytic = zeros(ComplexF64, nt, chunk) + coarse = zeros(T, length(config.coarse_rate), nm) + work = ( + adams=adams_workspace(input,nw,nm), + path=path_workspace(input,config), + raman=raman_workspace(input,config,nt,chunk), + plasma=plasma_workspace(input,config,nt,chunk,nm,size(config.synthesis,2)), + y=zeros(ComplexF64, nw, nm), candidate=zeros(ComplexF64, nw, nm), + lab=zeros(ComplexF64, nw, nm), source=zeros(ComplexF64, nw, nm), + fsal=zeros(ComplexF64, nw, nm), error=zeros(ComplexF64, nw, nm), + stages=zeros(ComplexF64, nw, nm, length(config.c)), + forward=zeros(ComplexF64, nw, nm, length(config.c)), inverse=zeros(ComplexF64, nw, nm, length(config.c)), + fine=fine, modal=modal, nodes=nodes, analytic=analytic, + projected=zeros(T,nt, nm), projected_coarse=zeros(T,nt,nm), coarse_spec=similar(fine), absorber=zeros(T,nt, nm), absorber_spec=similar(fine), + coarse=coarse, partials=zeros(3, nm), + inverse_plan=config.envelope ? plan_ifft(fft_storage(fine),1;flags=config.fft_flags) : plan_irfft(fft_storage(fine), nt, 1; flags=config.fft_flags), + forward_plan=config.envelope ? plan_fft(fft_storage(modal),1;flags=config.fft_flags) : plan_rfft(fft_storage(modal), 1; flags=config.fft_flags), + analytic_forward=plan_fft!(fft_storage(analytic), 1; flags=config.fft_flags), + analytic_inverse=plan_ifft!(fft_storage(analytic), 1; flags=config.fft_flags), + coarse_inverse=config.envelope ? plan_ifft(fft_storage(zeros(ComplexF64,nw,nm)),1;flags=config.fft_flags) : plan_irfft(fft_storage(zeros(ComplexF64,nw,nm)), length(config.coarse_rate), 1; flags=config.fft_flags), + coarse_forward=config.envelope ? plan_fft(fft_storage(coarse),1;flags=config.fft_flags) : plan_rfft(fft_storage(coarse), 1; flags=config.fft_flags), + ) + Engine(config, work, false, 0, NaN,config.factor) +end + +function load!(engine, input) + copyto!(engine.work.y, Matrix{ComplexF64}(input)) + mask!(engine, engine.work.y) + engine.fsal_valid = false + engine.calls = 0 + nothing +end + +function mask!(engine, values) + mask = engine.config.mask + foreach_sample(values, engine.config.tasks) do f,m,i + @inbounds begin + if !mask[f] + values[i] = 0 + end + end + end +end + +"""Evaluate the translated source, with padding/crop scales already in the seam.""" +function source!(engine, lab; quadrature=false) + c, w = engine.config, engine.work + c.free && return source_free!(engine,lab) + nt, nm = size(w.modal) + nw = size(lab, 1) + fill!(w.fine, 0) + foreach_sample(lab, c.tasks) do f,m,i + @inbounds begin + w.fine[c.crop[f],m] = lab[i] + end + end + fft_apply!(w.modal,w.inverse_plan,w.fine,c) + fill!(w.projected, 0) + quadrature && fill!(w.projected_coarse, 0) + clear_plasma!(w.plasma) + if engine.factor != 0 || !isnothing(w.plasma) || !isnothing(w.raman) + chunk = size(w.nodes,2) + for first in 1:chunk:size(c.synthesis,2) + last = min(first+chunk-1, size(c.synthesis,2)) + count = last-first+1 + nodes = @view w.nodes[:,1:count] + mul!(nodes, w.modal, @view(c.synthesis[:,first:last])) + if !isnothing(w.plasma) + plasma_current!(w.plasma,nodes,c,first) + project_plasma!(w.plasma,c,first,last,quadrature) + end + if c.envelope + isnothing(w.raman) || raman_response!(w.raman,nodes,nodes,c) + polarize_envelope!(nodes,nodes,c,engine.factor) + elseif c.analytic || (!isnothing(w.raman) && !w.raman.thg) + fill!(w.analytic, 0) + @views w.analytic[:,1:count] .= nodes + w.analytic_forward * w.analytic + foreach_sample(w.analytic, c.tasks) do f,m,i + @inbounds begin + w.analytic[i] *= (f == 1 || f == nt÷2+1) ? 1 : f <= nt÷2 ? 2 : 0 + end + end + fft_apply!(w.analytic,w.analytic_inverse,w.analytic,c) + isnothing(w.raman) || raman_response!(w.raman,nodes,w.analytic,c) + polarize!(nodes,c.analytic ? w.analytic : nodes,c,engine.factor) + else + isnothing(w.raman) || raman_response!(w.raman,nodes,w.analytic,c) + polarize!(nodes,nodes,c,engine.factor) + end + isnothing(w.raman) || add_raman!(w.raman,nodes,c) + mul!(w.projected, nodes, @view(c.projection[first:last,:]), 1.0, 1.0) + if quadrature && c.embedded + mul!(w.projected_coarse, nodes, @view(c.projection_coarse[first:last,:]), 1.0, 1.0) + end + end + end + mul!(w.fine, w.forward_plan, w.projected) + isnothing(w.plasma) || add_plasma!(w.fine,w.plasma,w.forward_plan,c) + in_stage_absorber = c.modal_in_stage_absorber + if in_stage_absorber + if c.split + fill!(w.absorber, 0) + else + foreach_sample(w.absorber, c.tasks) do t,m,i + @inbounds begin + w.absorber[i] = -0.5 * c.rate[t] * w.modal[i] + end + end + end + # The shared radial map has no temporal pad scale. Its loss is additive, + # independent of Kerr and its material prefactor, under either time scheme. + if !isempty(c.spatial_absorber) + mul!(w.absorber, w.modal, c.spatial_absorber, 1.0, 1.0) + end + mul!(w.absorber_spec, w.forward_plan, w.absorber) + end + foreach_sample(w.source, c.tasks) do f,m,i + @inbounds begin + value = c.prefactor[i] * c.omega_window[f] * w.fine[c.crop[f],m] + if in_stage_absorber && c.mask[f] + value += w.absorber_spec[c.crop[f],m] + end + w.source[i] = value + end + end + engine.calls += 1 + nothing +end + +# Constant linear tables make the propagators depend only on dz. Reuse is exact +# for equal step lengths; adaptive trials rebuild on every changed dz. +function propagators!(engine, dz) + engine.config.free && return + if !isnothing(engine.work.path) + path_propagators!(engine) + return + end + engine.config.cache_propagators && engine.propagator_dz == dz && return + c, w = engine.config, engine.work + n = length(w.y) + foreach_element(w.y,c.tasks) do i + @inbounds for stage in eachindex(c.c) + j = i + (stage-1)*n + exponent = (dz*c.c[stage])*c.linear[i] + w.forward[j] = exp(exponent) + w.inverse[j] = exp(-exponent) + end + end + engine.propagator_dz = dz + nothing +end + +"""Form one IP-DOPRI5 candidate, preserving y even when the controller rejects it.""" +function trial!(engine, dz::Float64) + c, w = engine.config, engine.work + nw, nm = size(w.y) + ns = length(c.c) + propagators!(engine,dz) + for stage in 1:ns + !c.free && !isnothing(w.path) && material_stage!(engine,stage) + if c.free && stage == 1 && engine.fsal_valid + # At c[1] == 0 the interaction-frame derivative is the FSAL source. + copyto!(@view(w.stages[:,:,1]),w.fsal) + continue + end + c.free && free_propagators!(engine,dz*c.c[stage]) + slot = c.free ? 1 : stage + foreach_sample(w.y, c.tasks) do f,m,i + @inbounds begin + combination = zero(ComplexF64) + for previous in 1:stage-1 + combination += c.a[stage,previous] * w.stages[i+(previous-1)*length(w.y)] + end + w.lab[i] = w.forward[i+(slot-1)*length(w.y)] * (w.y[i] + dz*combination) + end + end + if stage == 1 && engine.fsal_valid + copyto!(w.source, w.fsal) + else + source!(engine, w.lab; quadrature=stage==ns) + if stage == 1 + copyto!(w.fsal, w.source) + engine.fsal_valid = true + end + end + foreach_sample(w.source, c.tasks) do f,m,i + @inbounds begin + w.stages[i+(stage-1)*length(w.y)] = w.inverse[i+(slot-1)*length(w.y)] * w.source[i] + end + end + end + foreach_sample(w.y, c.tasks) do f,m,i + @inbounds begin + solution, defect = zero(ComplexF64), zero(ComplexF64) + for stage in 1:ns + value = w.stages[i+(stage-1)*length(w.y)] + solution += c.b[stage]*value + defect += c.e[stage]*value + end + flow = w.forward[i+(c.free ? 0 : ns-1)*length(w.y)] + w.candidate[i] = flow*(w.y[i]+dz*solution) + w.error[i] = flow*(dz*defect) + end + end + # Column partials retain a clear summation bound and require no per-trial arrays. + AK.foreachindex(1:nm; max_tasks=c.tasks, min_elems=max(1,cld(32768,nw))) do m + @inbounds begin + before, after = 0.0, 0.0 + for f in 1:nw + if c.norm_mask[f] + before += abs2(w.y[f,m]) + after += abs2(w.candidate[f,m]) + end + end + w.partials[1,m], w.partials[2,m] = before, after + end + end + magnitude = max(sqrt(sum(@view w.partials[1,:])), sqrt(sum(@view w.partials[2,:]))) + AK.foreachindex(1:nm; max_tasks=c.tasks, min_elems=max(1,cld(32768,nw))) do m + @inbounds begin + residual = 0.0 + for f in 1:nw + if c.norm_mask[f] + scale = c.rtol*c.weights[f]*magnitude+c.atol + value = w.error[f,m] + residual += scale == 0 && value == 0 ? 0.0 : abs2(value/scale) + end + end + w.partials[3,m] = residual + end + end + sqrt(sum(@view w.partials[3,:])) +end + +function commit!(engine, dz::Float64) + c, w = engine.config, engine.work + mask!(engine, w.candidate) + if c.split && any(!iszero, c.coarse_rate) + if c.free + split_free!(engine,dz) + else + fft_apply!(w.coarse,w.coarse_inverse,w.candidate,c) + nt = size(w.coarse,1) + foreach_sample(w.coarse, c.tasks) do t,m,i + @inbounds begin + w.coarse[i] *= exp(-0.5*dz*c.coarse_rate[t]) + end + end + mul!(w.candidate, w.coarse_forward, w.coarse) + end + mask!(engine, w.candidate) + engine.fsal_valid = false + else + if !c.low_storage + copyto!(w.fsal, w.source) + engine.fsal_valid = true + end + end + copyto!(w.y, w.candidate) + if !c.embedded + return NaN + end + mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) + isnothing(w.plasma) || add_plasma!(w.coarse_spec,w.plasma,w.forward_plan,c;coarse=true) + scale, defect = 0.0, 0.0 + for m in axes(w.y,2), f in axes(w.y,1) + weight = c.prefactor[f,m]*c.omega_window[f] + fine = weight*w.fine[c.crop[f],m] + coarse = weight*w.coarse_spec[c.crop[f],m] + scale += abs2(fine) + defect += abs2(coarse-fine) + end + scale == 0 ? NaN : sqrt(defect/scale) +end + +snapshot(engine) = copy(engine.work.y) +candidate(engine) = copy(engine.work.candidate) +source_snapshot(engine) = copy(engine.work.source) +error_snapshot(engine) = copy(engine.work.error) +function evaluate!(engine, input) + lab = Matrix{ComplexF64}(input) + source!(engine, lab) + source_snapshot(engine) +end + +# Plans have implementation-owned storage; explicitly owned arrays are counted here. +function ledger(engine) + result = Dict{String,Int}() + function visit(prefix,object) + for name in propertynames(object) + value=getproperty(object,name) + key="$(prefix).$(name)" + if value isa Array && !isempty(value) + result[key]=sizeof(value) + elseif value isa NamedTuple + visit(key,value) + end + end + end + visit("config",engine.config) + visit("work",engine.work) + result +end + +include("adams.jl") +include("rk4.jl") +include("stages.jl") +include("responses.jl") +include("free.jl") + +device_name(engine) = "cpu" +runtime() = (string(VERSION), Threads.nthreads(), FFTW.get_num_threads(), BLAS.get_num_threads(), string(BLAS.get_config())) +const rk4_b = rk4! +const configure_stages_b = configure_stages! +const load_b = load! +const trial_b = trial! +const commit_b = commit! +const evaluate_b = evaluate! + +end diff --git a/julia/src/adams.jl b/julia/src/adams.jl new file mode 100644 index 000000000..423411971 --- /dev/null +++ b/julia/src/adams.jl @@ -0,0 +1,229 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# SEP 16's resident exponential PEC. The Python march supplies scalar polynomial +# tables and chooses steps/orders; state-sized arithmetic and history stay here. +const RECIP_FACTORIAL = ntuple(k -> 1.0/factorial(k-1), 10) +function phi_values(x,::Val{N}) where N + if abs(x)>3.0 + out=ntuple(_->zero(ComplexF64),N+1) + out=Base.setindex(out,exp(x),1) + for k in 1:N + out=Base.setindex(out,(out[k]-RECIP_FACTORIAL[k])/x,k+1) + end + return out + end + levels=abs(x)<=0.5 ? 0 : ceil(Int,log2(abs(x)/0.5)) + y=x/2.0^levels + term=complex(RECIP_FACTORIAL[N+1]) + total=term + for m in 1:23 + term=term*y/(m+N) + total+=term + end + out=ntuple(_->zero(ComplexF64),N+1) + out=Base.setindex(out,total,N+1) + for k in N-1:-1:1 + out=Base.setindex(out,RECIP_FACTORIAL[k+1]+y*out[k+2],k+1) + end + out=Base.setindex(out,exp(y),1) + for _ in 1:levels + old=out + out=Base.setindex(out,old[1]*old[1],1) + for k in 1:N + value=old[1]*old[k+1] + for j in 1:k + value+=old[j+1]*RECIP_FACTORIAL[k-j+1] + end + out=Base.setindex(out,value/2.0^k,k+1) + end + end + out +end +phi_snapshot(x,order)=collect(phi_values(ComplexF64(x),Val(Int(order)))) + +function adams_workspace(input,nw,nm) + order=haskey(input,"adams_order") ? Int(input["adams_order"]) : 0 + order==0 && return nothing + slots=order+2 + width=order+1 + compensated=Bool(input["adams_compensated"]) + nphi=haskey(input,"phi_terms") ? size(Array{ComplexF64,3}(input["phi_terms"]),3) : 1 + (store=zeros(ComplexF64,nw,nm,slots), + states=zeros(ComplexF64,nw,nm,compensated ? slots : 0), + rates=zeros(ComplexF64,nw,nm,compensated ? slots : 0), + moments=zeros(ComplexF64,nw,nm,width), + carried=zeros(ComplexF64,nw,nm,compensated ? width-1 : 0), + endpoint=zeros(ComplexF64,compensated ? nw : 0,compensated ? nm : 0), + predictor=zeros(width,width),corrector=zeros(width,width),defects=zeros(3,2width), + spans=zeros(width),cpredictor=zeros(width),ccorrector=zeros(width),cdefects=zeros(3,width), + rate_weights=zeros(nphi),slots=zeros(Int,slots),sizes=zeros(Int,3), + norms=zeros(3,nm),compensated=compensated) +end +function configure_adams!(engine,predictor,corrector,defects,slots,spans,cpredictor,ccorrector,cdefects,rate) + a=engine.work.adams + p,q,d=Matrix{Float64}(predictor),Matrix{Float64}(corrector),Matrix{Float64}(defects) + order,width,count=size(p,1),size(q,1),size(d,1) + a.sizes .= (order,width,count) + a.predictor[1:order,1:order] .= p + a.corrector[1:width,1:width] .= q + a.defects[1:count,1:2width] .= d + incoming=Vector{Int}(slots) + a.slots[1:length(incoming)] .= incoming .+ 1 + if a.compensated + s,cp,cc=Vector{Float64}(spans),Vector{Float64}(cpredictor),Vector{Float64}(ccorrector) + a.spans[1:length(s)] .= s + a.cpredictor[1:length(cp)] .= cp + a.ccorrector[1:length(cc)] .= cc + a.cdefects[1:count,1:width] .= Matrix{Float64}(cdefects) + a.rate_weights .= Vector{Float64}(rate) + end + nothing +end +function configure_adams_rate!(engine,rate) + engine.work.adams.rate_weights .= Vector{Float64}(rate) + nothing +end +@inline function adams_rate(engine,f,m) + p,a=engine.work.path,engine.work.adams + isnothing(p) && return engine.config.linear[f,m] + value=0.0im + @inbounds for term in axes(p.phi,3) + value+=p.phi[f,m,term]*a.rate_weights[term] + end + value +end +function adams_start!(engine) + w=engine.work + isnothing(w.path) || material_stage!(engine,1) + source!(engine,w.y) + copyto!(@view(w.adams.store[:,:,1]),w.source) + if w.adams.compensated + copyto!(@view(w.adams.states[:,:,1]),w.y) + foreach_sample(w.y,engine.config.tasks) do f,m,i + @inbounds w.adams.rates[f,m,1]=adams_rate(engine,f,m) + end + end + nothing +end +function adams_trial!(engine,h) + adams_trial_width!(engine,h,Val(engine.work.adams.sizes[2])) +end +function adams_trial_width!(engine,h,::Val{N}) where N + c,w=engine.config,engine.work + a=w.adams + order,_,count=a.sizes + foreach_sample(w.y,c.tasks) do f,m,i + @inbounds begin + x=h*c.linear[i] + if !isnothing(w.path) + x=0.0im + for term in axes(w.path.phi,3) + x+=w.path.phi[f,m,term]*w.path.delta[term,end] + end + end + phi=phi_values(x,Val(N)) + w.forward[f,m,1]=phi[1] + value=0.0im + for k in 1:N + moment=phi[k+1]/RECIP_FACTORIAL[k] + a.moments[f,m,k]=moment + if k<=order + weighted=0.0im + for j in 1:order + weighted+=a.predictor[j,k]*a.store[f,m,a.slots[j]] + end + value+=moment*weighted + end + end + if a.compensated + correction=0.0im + for j in 1:N-1 + slot=a.slots[j] + carried=exp(a.spans[j]*x)*(a.rates[f,m,slot]-x/h)*a.states[f,m,slot] + a.carried[f,m,j]=carried + j<=order && (correction+=a.cpredictor[j]*carried) + end + value+=correction + w.error[i]=adams_rate(engine,f,m) + end + predicted=phi[1]*w.y[i]+h*value + w.lab[i]=predicted + if a.compensated + a.endpoint[i]=(w.error[i]-x/h)*predicted + end + end + end + isnothing(w.path) || material_stage!(engine,length(c.c)) + source!(engine,w.lab;quadrature=true) + magnitude=sqrt(masked_squared(engine,w.y)) + AK.foreachindex(axes(w.y,2);max_tasks=c.tasks,min_elems=max(1,cld(32768,size(w.y,1)))) do m + @inbounds begin + for row in 1:count + a.norms[row,m]=0.0 + end + for f in axes(w.y,1) + corrected=0.0im + for k in 1:N + weighted=a.corrector[1,k]*w.source[f,m] + for j in 2:N + weighted+=a.corrector[j,k]*a.store[f,m,a.slots[j-1]] + end + corrected+=a.moments[f,m,k]*weighted + end + if a.compensated + correction=a.ccorrector[1]*a.endpoint[f,m] + for j in 1:order + correction+=a.ccorrector[j+1]*a.carried[f,m,j] + end + corrected+=correction + end + w.candidate[f,m]=w.forward[f,m,1]*w.y[f,m]+h*corrected + if c.norm_mask[f] + scale=c.rtol*c.weights[f]*magnitude+c.atol + for row in 1:count + difference=a.defects[row,1]*w.source[f,m] + polynomial=0.0im + for j in 2:N + difference+=a.defects[row,j]*a.store[f,m,a.slots[j-1]] + end + for k in 1:N + polynomial+=a.defects[row,N+k]*a.moments[f,m,k] + end + defect=difference*polynomial + if a.compensated + correction=a.cdefects[row,1]*a.endpoint[f,m] + for j in 1:N-1 + correction+=a.cdefects[row,j+1]*a.carried[f,m,j] + end + defect+=correction + end + defect*=h + a.norms[row,m]+=scale==0 && defect==0 ? 0.0 : abs2(defect/scale) + end + end + end + end + end + [sqrt(sum(@view a.norms[row,:])) for row in 1:count] +end +function adams_accept!(engine,slot) + w=engine.work + copyto!(@view(w.adams.store[:,:,slot+1]),w.source) + if w.adams.compensated + copyto!(@view(w.adams.states[:,:,slot+1]),w.lab) + copyto!(@view(w.adams.rates[:,:,slot+1]),w.error) + end + nothing +end +adams_rows(engine,name)=copy(getproperty(engine.work.adams,Symbol(name))) +function adams_load_rows!(engine,name,rows) + copyto!(getproperty(engine.work.adams,Symbol(name)),Array{ComplexF64,3}(rows)) + nothing +end +const configure_adams_b=configure_adams! +const configure_adams_rate_b=configure_adams_rate! +const adams_start_b=adams_start! +const adams_trial_b=adams_trial! +const adams_accept_b=adams_accept! +const adams_load_rows_b=adams_load_rows! diff --git a/julia/src/free.jl b/julia/src/free.jl new file mode 100644 index 000000000..63b12dc97 --- /dev/null +++ b/julia/src/free.jl @@ -0,0 +1,267 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Cartesian geometry keeps shared coefficient vectors and one current-stage flow. +# FFT/array planning is CPU-specific; the scalar loops and Kerr body are shared. +function create_free(common, input) + vector(name,T) = Vector{T}(input[name]) + shape = Tuple(Int.(input["spatial_shape"])) + c = merge(common, ( + parallel_copy=get(ENV,"SOLPROP_JULIA_PARALLEL_COPY","1")=="1", + spatial_shape=shape, pad_scale=Float64(input["pad_scale"]), + spatial_rate=vector("spatial_rate",Float64), + k_squared=vector("k_squared",ComplexF64), k_squared_low=vector("k_squared_low",ComplexF64), + kperp_sq=vector("kperp_sq",Float64), kperp_sq_low=vector("kperp_sq_low",Float64), + frame=vector("frame",Float64), spectral_rate=vector("spectral_rate",Float64), + prefactor_numerator=vector("prefactor_numerator",ComplexF64), + prefactor_clamped=vector("prefactor_clamped",ComplexF64), active=vector("active",Bool), + kperp_rate=vector("kperp_rate",Float64), evanescent_rate=Float64(input["evanescent_rate"]), + )) + # Only an exactly absent additive source can omit these transforms. The + # accepted-step temporal split and the diagonal spectral loss are separate. + active_absorber = any(!iszero,c.spatial_rate) || (!c.split && any(!iszero,c.rate)) + c = merge(c, (in_stage_absorber=( + get(ENV,"SOLPROP_JULIA_SKIP_ZERO_ABSORBER","1") != "1" || active_absorber + ),)) + nw, nm, nt = length(c.crop), prod(shape), length(c.window) + chunk = min(Int(input["chunk"]),nm) + nf, nc = c.envelope ? nt : nt÷2+1, length(c.coarse_rate) + T = c.envelope ? ComplexF64 : Float64 + stages = c.low_storage ? 0 : length(c.c) + physical = zeros(ComplexF64,nw,nm) + spatial = view(reshape(physical,nw,shape...),:,:,:) + fine, modal = zeros(ComplexF64,nf,chunk), zeros(T,nt,chunk) + analytic = zeros(ComplexF64,nt,chunk) + coarse, coarse_spec = zeros(T,nc,chunk), zeros(ComplexF64,nw,chunk) + w = ( + plasma=plasma_workspace(input,c,nt,chunk,chunk,nm), + y=zeros(ComplexF64,nw,nm), candidate=zeros(ComplexF64,nw,nm), + lab=zeros(ComplexF64,nw,nm), source=zeros(ComplexF64,nw,nm), + fsal=zeros(ComplexF64,c.low_storage ? 0 : nw,c.low_storage ? 0 : nm), error=zeros(ComplexF64,nw,nm), + stages=zeros(ComplexF64,nw,nm,stages), + forward=zeros(ComplexF64,nw,nm,1), inverse=zeros(ComplexF64,nw,nm,c.low_storage ? 0 : 1), + physical=physical, loss=zeros(ComplexF64,nw,nm), + fine=fine, modal=modal, projected=zeros(T,nt,chunk), + analytic=analytic, absorber=zeros(T,nt,chunk), absorber_spec=similar(fine), + coarse=coarse, coarse_spec=coarse_spec, partials=zeros(3,nm), + spatial_inverse=plan_ifft!(spatial,(2,3);flags=c.fft_flags,num_threads=c.transverse_fft_threads), + spatial_forward=plan_fft!(spatial,(2,3);flags=c.fft_flags,num_threads=c.transverse_fft_threads), + inverse_plan=c.envelope ? plan_ifft(fft_storage(fine),1;flags=c.fft_flags) : plan_irfft(fft_storage(fine),nt,1;flags=c.fft_flags), + forward_plan=c.envelope ? plan_fft(fft_storage(modal),1;flags=c.fft_flags) : plan_rfft(fft_storage(modal),1;flags=c.fft_flags), + analytic_forward=plan_fft!(fft_storage(analytic),1;flags=c.fft_flags), + analytic_inverse=plan_ifft!(fft_storage(analytic),1;flags=c.fft_flags), + coarse_inverse=c.envelope ? plan_ifft(fft_storage(coarse_spec),1;flags=c.fft_flags) : plan_irfft(fft_storage(coarse_spec),nc,1;flags=c.fft_flags), + coarse_forward=c.envelope ? plan_fft(fft_storage(coarse),1;flags=c.fft_flags) : plan_rfft(fft_storage(coarse),1;flags=c.fft_flags), + ) + Engine(c,w,false,0,NaN,c.factor) +end + +# For an exactly real squared longitudinal wave number, the principal root is +# sqrt(x) for x>0 and i*sqrt(-x) for x<0. Preserve the imaginary signed zero and +# use the library complex root for lossy or nonfinite inputs. The compensated +# subtraction that forms q remains untouched; no near-zero cutoff is introduced. +@inline function free_root(q,specialize) + x,y=real(q),imag(q) + if specialize && iszero(y) && isfinite(x) + if x > 0 + return complex(sqrt(x),y) + elseif x < 0 + return complex(0.0,copysign(sqrt(-x),y)) + else + return complex(0.0,y) + end + end + sqrt(q) +end + +# Preserve the compensated subtraction order in translate.spatial.longitudinal_root. +# No fast-math or reassociation: near grazing, the residual determines the branch. +@inline function free_element(c,f,m) + @inbounds begin + q = (c.k_squared[f]-c.kperp_sq[m]) + (c.k_squared_low[f]-c.kperp_sq_low[m]) + root = free_root(q,c.real_root) + propagating = real(q) > 0 + attenuation = propagating ? imag(root) : min(abs(imag(root)),c.evanescent_rate) + rate = c.active[f] ? complex(-attenuation-0.5*c.kperp_rate[m],-(real(root)-c.frame[f])) : 0.0im + prefactor = propagating ? c.prefactor_numerator[f]/real(root) : c.prefactor_clamped[f] + return rate-0.5*c.spectral_rate[f], c.active[f] ? prefactor : 0.0im + end +end + +function free_propagators!(engine,h) + engine.propagator_dz == h && return + c,w = engine.config,engine.work + # The zero-distance stage is exactly identity; the final two DOPRI stages + # share a distance and can reuse this one scratch pair without dense caches. + if h == 0 + fill!(w.forward,1) + fill!(w.inverse,1) + engine.propagator_dz = h + return + end + foreach_sample(w.y,c.tasks) do f,m,i + @inbounds begin + rate,_ = free_element(c,f,m) + exponent = h*rate + # Both signs share exact trigonometric inputs, as in the compiled seam. + scale = exp(real(exponent)) + sine,cosine = sincos(imag(exponent)) + w.forward[i] = scale*complex(cosine,sine) + if !c.low_storage + w.inverse[i] = complex(cosine,-sine)/scale + end + end + end + engine.propagator_dz = h + nothing +end + +# Large source-entry copies are bandwidth passes. Reuse the shared traversal +# and its task threshold without changing element order or owned storage. +function copy_volume!(destination,source,c) + if c.parallel_copy + foreach_sample(destination,c.tasks) do f,m,i + @inbounds destination[i]=source[i] + end + else + copyto!(destination,source) + end + nothing +end + +function spatial_fft!(a,plan,c) + shaped = view(reshape(a,size(a,1),c.spatial_shape...),:,:,:) + fft_apply!(shaped,plan,shaped,c) + nothing +end + +function source_free!(engine,lab) + c,w = engine.config,engine.work + nt,chunk = size(w.modal) + nw,nm = size(lab) + copy_volume!(w.physical,lab,c) + spatial_fft!(w.physical,w.spatial_inverse,c) + # Transverse inversion precedes real temporal synthesis: individual transverse + # spectral columns do not themselves represent real temporal fields. + for first in 1:chunk:nm + count = min(chunk,nm-first+1) + fill!(w.fine,0) + foreach_sample(@view(w.physical[:,first:first+count-1]),c.tasks) do f,m,i + @inbounds w.fine[c.crop[f],m] = w.physical[f,first+m-1] + end + fft_apply!(w.modal,w.inverse_plan,w.fine,c) + if !isnothing(w.plasma) + # The temporal inverse is unscaled; plasma consumes SI nodal fields, + # with the same padding normalization as the Kerr response below. + foreach_sample(w.projected,c.tasks) do t,m,i + @inbounds w.projected[i]=c.pad_scale*w.modal[i] + end + plasma_current!(w.plasma,@view(w.projected[:,1:count]),c,first) + end + if c.envelope + foreach_sample(w.projected,c.tasks) do t,m,i + @inbounds begin + value=c.pad_scale*w.modal[i] + w.projected[i] = c.factor*c.analytic_factor*abs2(value)*value*c.window[t] + end + end + elseif c.analytic + foreach_sample(w.analytic,c.tasks) do t,m,i + @inbounds w.analytic[i] = c.pad_scale*w.modal[i] + end + w.analytic_forward*w.analytic + foreach_sample(w.analytic,c.tasks) do f,m,i + @inbounds w.analytic[i] *= (f == 1 || f == nt÷2+1) ? 1 : f <= nt÷2 ? 2 : 0 + end + fft_apply!(w.analytic,w.analytic_inverse,w.analytic,c) + polarize!(w.projected,w.analytic,c) + else + foreach_sample(w.projected,c.tasks) do t,m,i + @inbounds w.projected[i] = polarization(c.pad_scale*w.modal[i],c.factor,c.analytic_factor)*c.window[t] + end + end + mul!(w.fine,w.forward_plan,w.projected) + # The held-current equivalent polarization combines before the spatial + # forward FFT, exactly as the reference Cartesian source does. + isnothing(w.plasma) || add_plasma!(w.fine,w.plasma,w.forward_plan,c;direct=true) + if c.in_stage_absorber + foreach_sample(w.absorber,c.tasks) do t,m,i + @inbounds begin + rate = m <= count ? c.spatial_rate[first+m-1] : 0.0 + rate += c.split ? 0.0 : c.rate[t] + w.absorber[i] = -0.5*rate*w.modal[i] + end + end + mul!(w.absorber_spec,w.forward_plan,w.absorber) + end + foreach_sample(@view(w.physical[:,first:first+count-1]),c.tasks) do f,m,i + @inbounds begin + w.physical[f,first+m-1] = w.fine[c.crop[f],m] + if c.in_stage_absorber + w.loss[f,first+m-1] = w.absorber_spec[c.crop[f],m] + end + end + end + end + spatial_fft!(w.physical,w.spatial_forward,c) + c.in_stage_absorber && spatial_fft!(w.loss,w.spatial_forward,c) + foreach_sample(w.source,c.tasks) do f,m,i + @inbounds begin + _,prefactor = free_element(c,f,m) + w.source[i] = prefactor*c.omega_window[f]*w.physical[i] + (c.in_stage_absorber && c.mask[f] ? w.loss[i] : 0.0im) + end + end + engine.calls += 1 + nothing +end + +function split_free!(engine,dz) + c,w = engine.config,engine.work + copy_volume!(w.physical,w.candidate,c) + spatial_fft!(w.physical,w.spatial_inverse,c) + chunk = size(w.coarse,2) + for first in 1:chunk:size(w.candidate,2) + count = min(chunk,size(w.candidate,2)-first+1) + fill!(w.coarse_spec,0) + @views copyto!(w.coarse_spec[:,1:count],w.physical[:,first:first+count-1]) + fft_apply!(w.coarse,w.coarse_inverse,w.coarse_spec,c) + foreach_sample(w.coarse,c.tasks) do t,m,i + @inbounds w.coarse[i] *= exp(-0.5*dz*c.coarse_rate[t]) + end + mul!(w.coarse_spec,w.coarse_forward,w.coarse) + @views copyto!(w.physical[:,first:first+count-1],w.coarse_spec[:,1:count]) + end + spatial_fft!(w.physical,w.spatial_forward,c) + copy_volume!(w.candidate,w.physical,c) + nothing +end + +# Reuse the accepted-field observation scan on bounded physical-space chunks. +function population_free_snapshot(engine,input) + c,w=engine.config,engine.work + p=w.plasma + copyto!(w.physical,Matrix{ComplexF64}(input)) + spatial_fft!(w.physical,w.spatial_inverse,c) + chunk=size(w.modal,2) + parts=zeros(6,chunk) + maxima=zeros(6) + for first in 1:chunk:size(w.physical,2) + count=min(chunk,size(w.physical,2)-first+1) + fill!(w.fine,0) + foreach_sample(@view(w.physical[:,first:first+count-1]),c.tasks) do f,m,i + @inbounds w.fine[c.crop[f],m]=w.physical[f,first+m-1] + end + fft_apply!(w.modal,w.inverse_plan,w.fine,c) + foreach_sample(w.projected,c.tasks) do t,m,i + @inbounds w.projected[i]=c.pad_scale*w.modal[i] + end + nodes=@view(w.projected[:,1:count]) + AK.foreachindex(1:count;max_tasks=c.tasks,min_elems=1) do node + population_column!(p,nodes,node,first,parts) + end + @inbounds for node in 1:count, i in 1:6 + maxima[i]=max(maxima[i],parts[i,node]) + end + end + (copy(p.fractions),copy(p.peaks),maxima) +end diff --git a/julia/src/responses.jl b/julia/src/responses.jl new file mode 100644 index 000000000..fb86dbf3a --- /dev/null +++ b/julia/src/responses.jl @@ -0,0 +1,320 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Numerical execution of the translated scalar response. Rate tables, constants, +# FIR taps and temporal collar derivatives all come from schema 34 (SEP 18/27). +function plasma_workspace(input, c, nt, chunk, nm, nn) + (haskey(input,"plasma") && Bool(input["plasma"])) || return nothing + # Cartesian columns already are physical nodes. Only their current chunk + # needs temporal current spectra; no modal projection buffers are required. + projected_rows, projected_columns = c.free ? (0,0) : (nt,nm) + ( + coefficients=Matrix{Float64}(input["plasma_coefficients"]), + parameters=Vector{Float64}(input["plasma_parameters"]), + taps=Vector{Float64}(input["plasma_taps"]), floor=Bool(input["plasma_floor"]), + dt=Float64(input["dt"]), omega=Vector{Float64}(input["omega"]), + derivative=Vector{Float64}(input["window_derivative"]), + rate=zeros(nt,chunk), fraction=zeros(nt,chunk), integrand=zeros(nt,chunk), + current=zeros(nt,chunk), gated=zeros(nt,chunk), edge=zeros(nt,chunk), + projected=zeros(projected_rows,projected_columns), edge_projected=zeros(projected_rows,projected_columns), + coarse=zeros(projected_rows,projected_columns), coarse_edge=zeros(projected_rows,projected_columns), + spectrum=zeros(ComplexF64,nt÷2+1,nm), edge_spectrum=zeros(ComplexF64,nt÷2+1,nm), + fractions=zeros(nn), peaks=zeros(nn), + ) +end + +@inline function rate_value(value, p) + x=abs(value) + x < p.parameters[1] && return 0.0 + x >= p.parameters[2] && return p.parameters[3] + logarithm=log(x) + delta=logarithm-p.parameters[4] + j=clamp(floor(Int,delta/p.parameters[5])+1,1,size(p.coefficients,2)) + t=logarithm-(p.parameters[4]+(j-1)*p.parameters[5]) + @inbounds value=((p.coefficients[1,j]*t+p.coefficients[2,j])*t+p.coefficients[3,j])*t+p.coefficients[4,j] + min(exp(value),p.parameters[3]) +end + +# A symmetric FIR followed by a running trapezoid. Point reflection preserves +# the endpoint convention of RunningIntegral; no reassociation of this scan. +@inline function filtered(values,t,node,taps) + nt=size(values,1) + @inbounds value=taps[1]*values[t,node] + @inbounds for k in 1:length(taps)-1 + left=t-k < 1 ? 2*values[1,node]-values[1+k-t+1,node] : values[t-k,node] + right=t+k > nt ? 2*values[nt,node]-values[2nt-t-k,node] : values[t+k,node] + value += taps[k+1]*(left+right) + end + value +end +function integrate_column!(out,values,node,p) + previous=filtered(values,1,node,p.taps) + total=0.0 + @inbounds out[1,node]=0.0 + @inbounds for t in 2:size(values,1) + current=filtered(values,t,node,p.taps) + total += p.dt*(current+previous)/2 + out[t,node]=total + previous=current + end +end + +# On CPU, filter independent time samples before the dependent prefix. Keeping +# the tap loop outside the interior time loop exposes SIMD without reordering +# a sample's tap additions. The output itself is scratch until the strict scan, +# so this traversal does not add a persistent buffer. +# Exact zero support saves filter and prefix work outside the live interval. +# Reflection cannot extend this interval beyond the filter radius: its endpoint +# is already live whenever a reflected endpoint value is nonzero. +function integrate_column!(out::StridedMatrix,values::StridedMatrix,node,p) + nt=size(values,1) + half=length(p.taps)-1 + first=1 + @inbounds while first <= nt && iszero(values[first,node]) + first += 1 + end + fill!(@view(out[:,node]),0) + first > nt && return nothing + last=nt + @inbounds while iszero(values[last,node]) + last -= 1 + end + first=max(1,first-half) + last=min(nt,last+half) + if 2half >= nt + @inbounds for t in first:last + out[t,node]=filtered(values,t,node,p.taps) + end + else + @inbounds for t in first:min(half,last) + out[t,node]=filtered(values,t,node,p.taps) + end + @inbounds for t in max(nt-half+1,first):last + out[t,node]=filtered(values,t,node,p.taps) + end + interior_first=max(first,half+1) + interior_last=min(last,nt-half) + @inbounds @simd for t in interior_first:interior_last + out[t,node]=p.taps[1]*values[t,node] + end + @inbounds for k in 1:half + tap=p.taps[k+1] + @simd for t in interior_first:interior_last + out[t,node] += tap*(values[t-k,node]+values[t+k,node]) + end + end + end + @inbounds previous=out[1,node] + total=0.0 + @inbounds out[1,node]=0.0 + stop=min(nt,last+1) + @inbounds for t in max(2,first):stop + current=out[t,node] + total += p.dt*(current+previous)/2 + out[t,node]=total + previous=current + end + @inbounds for t in stop+1:nt + out[t,node]=total + end + nothing +end + +function plasma_current!(p,nodes,c,first) + AK.foreachindex(axes(nodes,2);max_tasks=c.tasks,min_elems=1) do node + peak=exposure_column!(p,nodes,node) + # With exactly zero rates and no initial electrons, both current streams + # vanish. Clear their outputs even if this chunk ionised on a prior call. + # The unused integrand/current scratch is overwritten on every live call. + if c.skip_zero_plasma && iszero(peak) && iszero(p.parameters[9]) + fill!(@view(p.gated[:,node]),0) + fill!(@view(p.edge[:,node]),0) + @inbounds p.fractions[first+node-1]=0.0 + @inbounds p.peaks[first+node-1]=0.0 + return + end + previous_exposure=NaN + fraction=0.0 + @inbounds for t in axes(nodes,1) + exposure=p.floor ? max(p.fraction[t,node],0.0) : p.fraction[t,node] + # An unchanged prefix gives the same fraction, including the exact + # zero-rate head and constant tail. No threshold or approximation. + if exposure != previous_exposure + fraction=1-(1-p.parameters[9])*exp(-exposure) + previous_exposure=exposure + end + p.fraction[t,node]=fraction + p.integrand[t,node]=fraction*p.parameters[6]*nodes[t,node] + end + integrate_column!(p.current,p.integrand,node,p) + @inbounds for t in axes(nodes,1) + field=nodes[t,node] + squared=field*field + loss=p.rate[t,node] > 0 && squared > 0 ? (p.parameters[7]*p.rate[t,node]*(1-p.fraction[t,node])/squared)*field : 0.0 + current=p.parameters[8]*(p.current[t,node]+loss) + p.gated[t,node]=c.window[t]*current + p.edge[t,node]=p.derivative[t]*current + end + @inbounds p.fractions[first+node-1]=p.fraction[size(nodes,1),node] + @inbounds p.peaks[first+node-1]=peak + end +end +function clear_plasma!(p) + isnothing(p) && return + for a in (p.projected,p.edge_projected,p.coarse,p.coarse_edge) + fill!(a,0) + end +end +function project_plasma!(p,c,first,last,quadrature) + count=last-first+1 + for (values,full,coarse) in ((p.gated,p.projected,p.coarse),(p.edge,p.edge_projected,p.coarse_edge)) + mul!(full,@view(values[:,1:count]),@view(c.projection[first:last,:]),1.0,1.0) + if quadrature && c.embedded + mul!(coarse,@view(values[:,1:count]),@view(c.projection_coarse[first:last,:]),1.0,1.0) + end + end +end +function add_plasma!(destination,p,plan,c;coarse=false,direct=false) + mul!(p.spectrum,plan,direct ? p.gated : coarse ? p.coarse : p.projected) + mul!(p.edge_spectrum,plan,direct ? p.edge : coarse ? p.coarse_edge : p.edge_projected) + foreach_sample(@view(destination[1:length(c.crop),:]),c.tasks) do f,m,i + @inbounds if c.mask[f] + k=c.crop[f] + inverse=1/p.omega[f] + destination[k,m] += -im*inverse*p.spectrum[k,m]+inverse^2*p.edge_spectrum[k,m] + end + end +end +# The source and observation share the translated rate and strict exposure scan. +function exposure_column!(p,nodes,node) + peak=0.0 + @inbounds for t in axes(nodes,1) + rate=rate_value(nodes[t,node],p) + p.rate[t,node]=rate + peak=max(peak,rate) + end + integrate_column!(p.fraction,p.rate,node,p) + peak +end + +# Observation scans read the accepted field afresh. They need rates and exposure, +# not the propagated current, Kerr/Raman response, projection or source FFTs. +function population_column!(p,nodes,node,first,parts) + nt=size(nodes,1) + peak=exposure_column!(p,nodes,node) + dip=rise=paid=early=maximum_integrand=0.0 + previous_exposure=0.0 + previous_product=0.0 + initial_fraction=0.0 + reach=2(length(p.taps)-1) + @inbounds for t in 1:nt + exposure=p.fraction[t,node] + if t > 1 + increment=exposure-previous_exposure + dip=max(dip,-increment) + rise=max(rise,increment) + end + previous_exposure=exposure + fraction=1-(1-p.parameters[9])*exp(-(p.floor ? max(exposure,0.0) : exposure)) + p.fraction[t,node]=fraction + product=p.rate[t,node]*(1-fraction) + if t == 1 + initial_fraction=fraction + else + # Keep this diagnostic trapezoid ordered and strict, like the prefix. + paid += p.dt*(product+previous_product)/2 + end + previous_product=product + integrand=abs(fraction*nodes[t,node]) + maximum_integrand=max(maximum_integrand,integrand) + if t <= reach + early=max(early,integrand) + end + end + @inbounds begin + freed=p.fraction[nt,node]-initial_fraction + p.fractions[first+node-1]=p.fraction[nt,node] + p.peaks[first+node-1]=peak + parts[1,node]=dip + parts[2,node]=rise + parts[3,node]=abs(paid-freed) + parts[4,node]=freed + parts[5,node]=early + parts[6,node]=maximum_integrand + end + nothing +end +function population_snapshot(engine,input) + engine.config.free && return population_free_snapshot(engine,input) + c,w=engine.config,engine.work + p=w.plasma + lab=Matrix{ComplexF64}(input) + fill!(w.fine,0) + foreach_sample(lab,c.tasks) do f,m,i + @inbounds w.fine[c.crop[f],m]=lab[i] + end + fft_apply!(w.modal,w.inverse_plan,w.fine,c) + chunk=size(w.nodes,2) + # Observation-only transient reductions are outside the owned march buffers. + parts=zeros(6,chunk) + maxima=zeros(6) + for first in 1:chunk:size(c.synthesis,2) + last=min(first+chunk-1,size(c.synthesis,2)) + count=last-first+1 + nodes=@view w.nodes[:,1:count] + mul!(nodes,w.modal,@view(c.synthesis[:,first:last])) + AK.foreachindex(1:count;max_tasks=c.tasks,min_elems=1) do node + population_column!(p,nodes,node,first,parts) + end + @inbounds for node in 1:count, i in 1:6 + maxima[i]=max(maxima[i],parts[i,node]) + end + end + (copy(p.fractions),copy(p.peaks),maxima) +end + +function raman_workspace(input,c,nt,chunk) + (haskey(input,"raman") && Bool(input["raman"])) || return nothing + rows=Matrix{Float64}(input["raman_undamped"]) + rates=Vector{Float64}(input["raman_rates"]) + dt=Float64(input["dt"]) + kernel=zeros(2nt,1) + for term in eachindex(rates), t in 1:2nt + @inbounds kernel[t] += rows[t,term]*exp(-rates[term]*(t-1)*dt) + end + kernel .*= Float64(input["raman_fraction"]) + plan=plan_rfft(fft_storage(kernel),1;flags=c.fft_flags,num_threads=1) + # MEASURE may overwrite its planning input. + fill!(kernel,0) + for term in eachindex(rates), t in 1:2nt + @inbounds kernel[t] += rows[t,term]*exp(-rates[term]*(t-1)*dt) + end + kernel .*= Float64(input["raman_fraction"]) + spectrum=vec(plan*kernel).*dt + drive=zeros(2nt,chunk) + frequency=zeros(ComplexF64,nt+1,chunk) + (kernel=spectrum,factor=Float64(input["raman_factor"]),thg=Bool(input["raman_thg"]), + drive=drive,frequency=frequency,result=zeros(c.envelope ? ComplexF64 : Float64,nt,chunk), + forward=plan_rfft(fft_storage(drive),1;flags=c.fft_flags,num_threads=c.raman_fft_threads), + inverse=plan_irfft(fft_storage(frequency),2nt,1;flags=c.fft_flags,num_threads=c.raman_fft_threads)) +end +function raman_response!(r,nodes,analytic,c) + nt,count=size(nodes) + fill!(r.drive,0) + foreach_sample(nodes,c.tasks) do t,m,i + @inbounds r.drive[t,m]=r.thg ? abs2(nodes[i]) : 0.5*abs2(analytic[t,m]) + end + mul!(r.frequency,r.forward,r.drive) + foreach_sample(r.frequency,c.tasks) do f,m,i + @inbounds r.frequency[i] *= r.kernel[f] + end + fft_apply!(r.drive,r.inverse,r.frequency,c) + foreach_sample(nodes,c.tasks) do t,m,i + @inbounds r.result[t,m]=r.factor*nodes[i]*r.drive[t,m] + end +end +function add_raman!(r,nodes,c) + foreach_sample(nodes,c.tasks) do t,m,i + @inbounds nodes[i] += r.result[t,m]*c.window[t] + end +end diff --git a/julia/src/rk4.jl b/julia/src/rk4.jl new file mode 100644 index 000000000..725247dfd --- /dev/null +++ b/julia/src/rk4.jl @@ -0,0 +1,56 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The four register passes of the existing SEP 24 scheme. A constant flow's key +# is the schedule run's mean step, supplied by the shared table_steps policy. +function masked_squared(engine,a) + c,w=engine.config,engine.work + AK.foreachindex(axes(a,2);max_tasks=c.tasks,min_elems=1) do m + value=0.0 + @inbounds for f in axes(a,1) + if c.norm_mask[f] + value += abs2(a[f,m]) + end + end + w.partials[1,m]=value + end + sum(@view w.partials[1,:]) +end +function rk4!(engine,dz::Float64,key::Float64) + c,w=engine.config,engine.work + free_propagators!(engine,key/2) + source!(engine,w.y) + foreach_sample(w.y,c.tasks) do f,m,i + @inbounds begin + w.y[i] *= w.forward[i] + slope=w.forward[i]*w.source[i] + w.error[i]=slope + w.candidate[i]=w.y[i]+(dz/6)*slope + w.lab[i]=w.y[i]+(dz/2)*slope + end + end + source!(engine,w.lab) + foreach_sample(w.y,c.tasks) do f,m,i + @inbounds begin + w.error[i]=w.source[i]-w.error[i] + w.candidate[i] += (dz/3)*w.source[i] + w.lab[i]=w.y[i]+(dz/2)*w.source[i] + end + end + lower=masked_squared(engine,w.error) + copy_volume!(w.error,w.source,c) + source!(engine,w.lab) + foreach_sample(w.y,c.tasks) do f,m,i + @inbounds begin + w.error[i]=w.source[i]-w.error[i] + w.candidate[i] += (dz/3)*w.source[i] + w.lab[i]=w.forward[i]*(w.y[i]+dz*w.source[i]) + end + end + upper=masked_squared(engine,w.error) + source!(engine,w.lab) + foreach_sample(w.y,c.tasks) do f,m,i + @inbounds w.candidate[i]=w.forward[i]*w.candidate[i]+(dz/6)*w.source[i] + end + (masked_squared(engine,w.candidate),lower > 0 ? 2sqrt(upper/lower) : NaN) +end diff --git a/julia/src/stages.jl b/julia/src/stages.jl new file mode 100644 index 000000000..5a121a049 --- /dev/null +++ b/julia/src/stages.jl @@ -0,0 +1,50 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The translation layer owns the expansion and its scalar evaluation. No pressure +# law or material formula crosses this boundary: only fixed arrays and weights. +function path_workspace(input,c) + haskey(input,"phi_terms") || return nothing + phi=Array{ComplexF64,3}(input["phi_terms"]) + pre=Array{ComplexF64,3}(input["prefactor_terms"]) + (phi=phi,prefactor=pre,delta=zeros(size(phi,3),length(c.c)), + weights=zeros(size(pre,3),length(c.c)),material=zeros(3,length(c.c))) +end +function configure_stages!(engine,delta,weights,material) + p=engine.work.path + copyto!(p.delta,Matrix{Float64}(delta)) + copyto!(p.weights,Matrix{Float64}(weights)) + copyto!(p.material,Matrix{Float64}(material)) + material_stage!(engine,1) + nothing +end +function material_stage!(engine,stage) + c,w=engine.config,engine.work + p=w.path + foreach_sample(c.prefactor,c.tasks) do f,m,i + value=0.0im + @inbounds for term in axes(p.prefactor,3) + value += p.prefactor[f,m,term]*p.weights[term,stage] + end + @inbounds c.prefactor[i]=value + end + engine.factor=p.material[1,stage] + if !isnothing(w.plasma) + w.plasma.parameters[8]=p.material[2,stage] + w.plasma.parameters[9]=p.material[3,stage] + end +end +function path_propagators!(engine) + c,w=engine.config,engine.work + p=w.path + foreach_sample(w.y,c.tasks) do f,m,i + @inbounds for stage in eachindex(c.c) + exponent=0.0im + for term in axes(p.phi,3) + exponent += p.phi[f,m,term]*p.delta[term,stage] + end + w.forward[f,m,stage]=exp(exponent) + w.inverse[f,m,stage]=exp(-exponent) + end + end +end diff --git a/julia/test/runtests.jl b/julia/test/runtests.jl new file mode 100644 index 000000000..b92baafab --- /dev/null +++ b/julia/test/runtests.jl @@ -0,0 +1,101 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +using Test, SolpropJulia, LinearAlgebra +import FFTW +const S = SolpropJulia + +function configuration(tasks) + nw, nm, nt = 5, 2, 16 + # A constant linear problem with the same seven-stage interface; the source + # vanishes, so the analytic exponential is independent of tableau coefficients. + Dict( + "linear" => fill(-0.1 + 0.2im, nw, nm), + "prefactor" => zeros(ComplexF64,nw,nm), + "synthesis" => Matrix{Float64}(I,nm,nm), + "projection" => Matrix{Float64}(I,nm,nm), + "projection_coarse" => Matrix{Float64}(I,nm,nm), + "embedded" => false, "crop" => collect(0:nw-1), + "mask" => [false,true,true,true,false], "norm_mask" => trues(nw), + "weights" => ones(nw), "window" => ones(nt), "omega_window" => ones(nw), + "rate" => zeros(nt), "coarse_rate" => zeros(2(nw-1)), + "a" => zeros(7,7), "b" => zeros(7), "e" => zeros(7), + "c" => collect(range(0,1;length=7)), "factor" => 0.0, + "analytic" => false, "analytic_factor" => 0.0, "split" => false, + "rtol" => 1e-8, "atol" => 1e-14, + "threads" => tasks, "fft_threads" => 1, "blas_threads" => 1, "chunk" => 1, + ) +end + +@testset "filtered prefix, reflected endpoints and overlapping halos" begin + for nt in (9,256), half in (0,2,8) + values=reshape([sin(0.2t)+0.01t for t in 1:2nt],nt,2) + taps=[(-0.2)^k for k in 0:half] + out=similar(values) + for node in 1:2 + x=values[:,node] + extended=vcat(2x[1].-x[half+1:-1:2],x,2x[end].-x[end-1:-1:end-half]) + smooth=[sum(taps[k+1]*(k==0 ? extended[t+half] : + extended[t+half-k]+extended[t+half+k]) for k in 0:half) + for t in 1:nt] + expected=vcat(0.0,cumsum(0.03.*(smooth[1:end-1].+smooth[2:end])./2)) + S.integrate_column!(out,values,node,(taps=taps,dt=0.03)) + # Independent finite convolution and prefix summations: account for + # filter width and every prefix addition, including cancellation. + bound=128eps()*nt*(half+1)*norm(expected) + @test norm(out[:,node]-expected) <= bound + @test out[1,node] == 0 + end + end +end + +@testset "owned state, transforms, masks, rejection and task widths" begin + for tasks in unique([1,Threads.nthreads()]) + engine = S.create(configuration(tasks)) + initial = complex.(reshape(collect(1.0:10.0),5,2), 0.3) + S.load!(engine, initial) + before = S.snapshot(engine) + initial .= 0 + @test any(!iszero,before) + @test all(iszero, before[[1,5],:]) + @test S.trial!(engine, 0.2) == 0 + @test S.snapshot(engine) == before + # Discard the first candidate and try a different step length. + @test S.trial!(engine, 0.1) == 0 + S.commit!(engine, 0.1) + @test S.snapshot(engine) ≈ before .* exp.((-.1+.2im)*.1) rtol=8eps() + @test engine.calls == 13 + @test sum(values(S.ledger(engine))) > 0 + fine = engine.work.fine + fine .= 0 + fine[2:4,:] .= before[2:4,:] + expected = copy(fine) + mul!(engine.work.modal,engine.work.inverse_plan,fine) + mul!(fine,engine.work.forward_plan,engine.work.modal) + # Two length-16 FFTs: a normwise O(eps log N) backward-error budget. + @test norm(fine-expected) <= 32eps()*log2(16)*norm(expected) + S.load!(engine,zeros(ComplexF64,5,2)) + @test S.trial!(engine,0.1) == 0 + S.commit!(engine,0.1) + @test all(iszero,S.snapshot(engine)) + end +end + +@testset "exact zero support retains reflected and prefix conventions" begin + for nt in (9,256), half in (0,2,8), interval in (1:0,1:1,nt:nt,1:nt,3:6) + values=zeros(nt,1) + for t in interval + values[t,1]=cos(0.7t) + end + p=(taps=[(-0.2)^k for k in 0:half],dt=0.03) + out=fill(NaN,nt,1) + # Invoke the retained generic traversal as an independent witness to + # support pruning, including exact zeros and both reflected endpoints. + expected=similar(out) + invoke(S.integrate_column!,Tuple{Any,Any,Any,Any},expected,values,1,p) + S.integrate_column!(out,values,1,p) + bound=128eps()*nt*(half+1)*max(norm(expected),floatmin(Float64)) + @test norm(out-expected) <= bound + @test all(isfinite,out) + end +end diff --git a/src/solprop/backends/julia/__init__.py b/src/solprop/backends/julia/__init__.py new file mode 100644 index 000000000..f6fbfe5eb --- /dev/null +++ b/src/solprop/backends/julia/__init__.py @@ -0,0 +1,9 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The Julia backend experiment: CPU, or an NVIDIA GPU with ``SOLPROP_JULIA_DEVICE``.""" + +from solprop.backends.julia._backend import JuliaBackend +from solprop.backends.julia._runtime import source_digest + +__all__ = ["JuliaBackend", "source_digest"] diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py new file mode 100644 index 000000000..82d73e861 --- /dev/null +++ b/src/solprop/backends/julia/_backend.py @@ -0,0 +1,865 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Adapt the existing step driver to the experimental Julia-owned state.""" + +import dataclasses +import logging +import math +from collections.abc import Mapping, Sequence +from typing import Literal + +import numpy as np +from jaxtyping import Complex + +from solprop._helpers import PLAIN +from solprop.backends.driver import StepDriver, refuse_general_leaves +from solprop.backends.exponential import refuse_carrier_frame +from solprop.backends.julia._runtime import ( + call_julia, + runtime, + source_digest, + thread_limit, +) +from solprop.backends.multistep import source_absent +from solprop.backends.numpy_ref.passes import plasma_integration_statistics +from solprop.backends.spatial import collect_spatial, radial_absorber_matrix +from solprop.constants import EPS0 +from solprop.exceptions import BackendError +from solprop.grid import TimeGrid +from solprop.modes.protocol import Mode +from solprop.noise import NoiseRealisation +from solprop.output.schema import SavedPlane +from solprop.profiles import ZProfile +from solprop.stats import ( + _POYNTING_STATISTICS, + StatsSpec, + _poynting_statistics, + collect, + default_spec, +) +from solprop.stepper import LowStorageRungeKutta, Multistep +from solprop.stepper.tableau import DOPRI5 +from solprop.translate.chebyshev import PiecewiseChebyshev +from solprop.translate.linop import power_weight_at +from solprop.translate.problem import KernelProblem +from solprop.translate.stage import terms + +__all__ = ["JuliaBackend"] + +logger = logging.getLogger(__name__) +_SPECIES_STATS = frozenset( + ( + "species_density", + "species_electron_density", + "species_ionisation", + "species_ionisation_energy", + "species_peak_ionisation_rate", + "electron_density", + "peak_ionisation_rate", + "plasma_undershoot", + "plasma_work_defect", + "plasma_boundary_level", + ) +) +_SUPPORTED_STATS = ( + frozenset(default_spec("multimode", with_profiles=True).names) + | _SPECIES_STATS + | {"peak_intensity", "quadrature_error"} +) +_SPATIAL_STATS = ( + frozenset(default_spec("radial", with_profiles=True).names) | _SPECIES_STATS +) + + +def _constant(table: PiecewiseChebyshev | None) -> bool: + """Check the whole polynomial, not just samples at a few positions. + + Parameters + ---------- + table : solprop.translate.chebyshev.PiecewiseChebyshev or None + Translated scalar table. + + Returns + ------- + bool + Whether the table is absent or constant over every interval. + """ + if table is None: + return True + coefficients = table.coefficients + return bool( + np.all(coefficients[:, 1:] == 0) + and np.all(coefficients[:, 0] == coefficients[0, 0]) + ) + + +def _refuse(problem: KernelProblem) -> None: + """Refuse unsupported leaves before starting Julia or allocating its state. + + Parameters + ---------- + problem : solprop.translate.problem.KernelProblem + Translated schema contract. + + Raises + ------ + BackendError + If a requested leaf is outside the prototype's scope. + """ + response, transform, linear, stepper = ( + problem.responses, + problem.transform, + problem.linear, + problem.stepper, + ) + reasons = { + "single precision": problem.precision.single, + "envelope plasma": problem.grid_kind == "envelope" and problem.flags.has_plasma, + "resolved modal or radial envelopes": problem.grid_kind == "envelope" + and transform.kind not in {"free", "mode_averaged"}, + "envelope harmonics": problem.grid_kind == "envelope" + and response.kerr_coefficients is not None + and response.kerr_coefficients.harmonic_factor != 0, + "single batch and scalar polarisation": problem.shape[0] != 1 + or problem.shape[2] != 1 + or transform.n_pol != 1, + "planar transforms": transform.geometry is not None + and transform.geometry.kind not in {"radial", "free"}, + "nonseparable longitudinal tables": not terms(problem).device_ready, + "varying radius": transform.taper_scale is not None, + "multiple plasma channels": len(response.plasma_channels) > 1, + "multiple Raman components": len(response.raman_terms) > 1, + "varying Raman coefficients": any( + not _constant(r.density or response.density) + or any(not _constant(v) for v in r.decay_rates) + for r in response.raman_terms + ), + "Cartesian Raman": problem.flags.has_raman and transform.kind == "free", + "spectral responses": problem.flags.has_spectral_responses, + "dispersive Kerr": response.dispersive_kerr is not None, + "separable responses off free space": response.separable is not None + and transform.kind != "free", + "TDSE": problem.tdse is not None, + "noise": problem.flags.has_noise, + "interaction or comparison Adams integration": isinstance( + stepper.integrator, Multistep + ) + and ( + type(stepper.integrator) is not Multistep + or stepper.integrator.formulation != "exponential" + ), + "Cartesian Adams integration": isinstance(stepper.integrator, Multistep) + and transform.kind == "free", + "non-Cartesian low-storage integration": isinstance( + stepper.integrator, LowStorageRungeKutta + ) + and transform.kind != "free", + "non-DOPRI5 tableau": stepper.tableau is not DOPRI5, + "interpolated planes": stepper.interpolate_planes, + } + for reason, refused in reasons.items(): + if refused: + raise BackendError(f"julia does not support {reason}") + refuse_general_leaves(problem, "julia") + refuse_carrier_frame(problem, "julia") + _refuse_stats(problem.stats_spec, spatial=transform.geometry is not None) + + +def _compensated(problem: KernelProblem) -> bool: + """Use the exact chord for structurally absent sources, as SEP 16 requires.""" + return problem.linear.phi_representation in { + "expansion", + "table", + } and not source_absent(problem) + + +def _varying(problem: KernelProblem) -> bool: + """Identify stage-dependent material scales and longitudinal expansions.""" + response = problem.responses + return ( + problem.linear.phi_expansion is not None + or response.prefactor_expansion is not None + or not _constant(response.density) + or ( + response.kerr_coefficients is not None + and not _constant(response.kerr_coefficients.density) + ) + or any( + not _constant(c.density) or not _constant(c.preionisation) + for c in response.plasma_channels + ) + ) + + +def _refuse_stats(spec: StatsSpec, *, spatial: bool = False) -> None: + """Name statistics outside the prototype's declared scope. + + Parameters + ---------- + spec : solprop.stats.StatsSpec + Requested statistics. + spatial : bool, optional + Whether to use the spatial default/profile statistics subset. + + Raises + ------ + BackendError + If any requested statistic is unsupported. + """ + if missing := set(spec.names) - (_SPATIAL_STATS if spatial else _SUPPORTED_STATS): + raise BackendError( + f"julia does not support statistics {sorted(missing)}" + ) + + +def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: + """Copy the validated constant seam into Julia's frequency-first layout. + + Parameters + ---------- + problem : solprop.translate.problem.KernelProblem + Validated constant scalar modal or spatial contract. + threads : int + Positive Julia task limit. + + Returns + ------- + dict + Owning arrays and scalar configuration consumed once by Julia. + """ + grids, responses, transform = problem.grids, problem.responses, problem.transform + shape = problem.shape + kerr = responses.kerr_coefficients + density = ( + kerr.density + if kerr is not None and kerr.density is not None + else responses.density + ) + factor = ( + 0.0 if kerr is None else kerr.coefficient * float(density.coefficients[0, 0]) + ) + control, tableau = problem.stepper.controller, problem.stepper.tableau + chunk = min(transform.node_chunk, transform.n_nodes) + temporal_columns = chunk if transform.kind == "free" else shape[1] + # Short one-column transforms lose to task startup. The Xeon A/B sweep + # retained serial transforms below 16k real-side samples, a four-thread cap + # above it, and an independent cap for the doubled Raman convolution. + fft_default = 1 if grids.n_to * temporal_columns < 16384 else min(threads, 4) + raman_default = 1 if 2 * grids.n_to * chunk < 16384 else min(threads, 4) + fft_threads = thread_limit("SOLPROP_JULIA_FFT_THREADS", fft_default) + blas_default = 1 if transform.kind == "mode_averaged" else min(threads, 4) + config: dict[str, object] = { + "adams_order": problem.stepper.integrator.order + if isinstance(problem.stepper.integrator, Multistep) + else 0, + "adams_compensated": _compensated(problem), + "plasma": bool(responses.plasma_channels), + "raman": bool(responses.raman_terms), + "envelope": problem.grid_kind == "envelope", + "low_storage": isinstance(problem.stepper.integrator, LowStorageRungeKutta), + "free": transform.kind == "free", + "linear": np.zeros( + (0, 0) if transform.kind == "free" else (shape[-1], shape[1]), dtype=complex + ) + if problem.linear.phi_constant is None + else np.broadcast_to(problem.linear.phi_constant, shape)[0, :, 0, :].T.copy(), + "prefactor": np.zeros( + (0, 0) if transform.kind == "free" else (shape[-1], shape[1]), dtype=complex + ) + if responses.prefactor_constant is None + else np.broadcast_to(responses.prefactor_constant, shape[1:])[:, 0, :].T.copy(), + # Mode averaging already folds the effective-area conversion into synthesis + # and its reciprocal into prefactor; the shared one-node path uses both. + "synthesis": transform.synthesis.T.copy(), + "projection": transform.projection.T.copy(), + "projection_coarse": transform.projection_coarse.T.copy(), + "spatial_absorber": radial_absorber_matrix(transform, grids.pad_scale).T.copy(), + "embedded": not np.array_equal( + transform.projection, transform.projection_coarse + ), + "crop": grids.crop_index.copy(), + "mask": grids.active_mask.copy(), + "norm_mask": grids.norm_mask.copy(), + "weights": np.ones(shape[-1]) + if control.weights is None + else control.weights.copy(), + "window": grids.t_window_fine.copy(), + "omega_window": grids.omega_window.copy(), + "rate": np.zeros(grids.n_to) + if responses.temporal_absorber_fine is None + else responses.temporal_absorber_fine.copy(), + "coarse_rate": np.zeros(grids.n_t) + if responses.temporal_absorber is None + else responses.temporal_absorber.copy(), + "a": tableau.matrix.copy(), + "b": tableau.solution_weights.copy(), + "e": tableau.error_weights.copy(), + "c": tableau.nodes.copy(), + "factor": factor, + "analytic": kerr is not None and kerr.analytic_signal, + "analytic_factor": 0.0 + if kerr is None + else kerr.self_factor + kerr.conjugate_factor, + "split": responses.absorber_scheme == "split_step", + "rtol": control.rtol, + "atol": control.atol, + "cache_propagators": transform.kind != "free" + and problem.stepper.propagator_mode != "recompute", + "threads": threads, + "fft_threads": fft_threads, + "raman_fft_threads": thread_limit( + "SOLPROP_JULIA_RAMAN_FFT_THREADS", raman_default + ), + "transverse_fft_threads": fft_threads, + "blas_threads": thread_limit("SOLPROP_JULIA_BLAS_THREADS", blas_default), + "chunk": transform.node_chunk, + } + + if _varying(problem): + held = terms(problem) + assert held.phi is not None and held.prefactor is not None + config.update( + phi_terms=np.broadcast_to(held.phi, (len(held.phi), *shape))[:, 0, :, 0, :] + .transpose(2, 1, 0) + .copy(), + prefactor_terms=np.broadcast_to( + held.prefactor, (len(held.prefactor), *shape[1:]) + )[:, :, 0, :] + .transpose(2, 1, 0) + .copy(), + ) + + if responses.plasma_channels: + channel = responses.plasma_channels[0] + table = channel.rate + config.update( + plasma_coefficients=table.coefficients.copy(), + plasma_parameters=np.array( + [ + table.field_min, + table.field_max, + table.rate_max, + table.log_field_min, + table.d_log_field, + channel.charge_mass_ratio, + channel.ionisation_potential, + float(channel.density(0.0)), + float(channel.preionisation(0.0)), + ] + ), + plasma_taps=responses.plasma_integral.taps.copy(), + plasma_floor=responses.plasma_integral.policy == "band", + dt=grids.dt_fine, + window_derivative=grids.t_window_fine_derivative.copy(), + omega=grids.omega.copy(), + ) + + if responses.raman_terms: + raman = responses.raman_terms[0] + config.update( + raman_undamped=raman.undamped.T.copy(), + raman_rates=np.array([float(rate(0.0)) for rate in raman.decay_rates]), + raman_fraction=raman.fraction, + raman_factor=EPS0 * float((raman.density or responses.density)(0.0)), + raman_thg=raman.thg, + dt=grids.dt_fine, + ) + + if transform.kind == "free": + data, geometry = problem.linear.separable, transform.geometry + assert data is not None and geometry is not None + config.update( + spatial_shape=geometry.shape, + pad_scale=grids.pad_scale, + spatial_rate=geometry.absorber_rate.copy(), + evanescent_rate=data.evanescent_rate, + ) + for name in ( + "k_squared", + "k_squared_low", + "kperp_sq", + "kperp_sq_low", + "frame", + "spectral_rate", + "prefactor_numerator", + "prefactor_clamped", + "active", + "kperp_rate", + ): + value = getattr(data, name) + assert value is not None + config[name] = value.copy() + return config + + +class JuliaBackend(StepDriver[object]): + """Propagate the experimental scalar core subset with resident Julia kernels. + + Parameters + ---------- + problem : solprop.translate.problem.KernelProblem + Supported modal or spatial problem, in SI units and complex128. + grid : solprop.grid.TimeGrid, optional + Temporal grid, needed for statistics. + modes : collections.abc.Sequence, optional + Modes passed to the shared host statistics functions. + profiles : collections.abc.Mapping, optional + Profiles passed to the shared host statistics functions. + + Raises + ------ + BackendError + If the problem or the private Julia runtime is unsupported. + """ + + name = "julia" + max_batch = 1 + # Shared scalar tables and bookkeeping remain plain Python. Numerical state + # and complete propagation trials stay in Julia. + helpers = PLAIN + propagator_default = "tabulate" + + def __init__( + self, + problem: KernelProblem, + *, + grid: TimeGrid | None = None, + modes: Sequence[Mode] | None = None, + profiles: Mapping[str, ZProfile] | None = None, + ) -> None: + _refuse(problem) + problem.validate() + super().__init__(problem, grid=grid, modes=modes, profiles=profiles) + self._jl = runtime() + # The loaded module is the one on disk: a source edit after the runtime + # started would otherwise time or test stale code. + if str(self._jl.loaded_digest()) != source_digest(): + raise BackendError("julia sources changed after the runtime loaded them") + self._threads = thread_limit("SOLPROP_JULIA_THREADS") + if not 1 <= self._threads <= int(self._jl.runtime()[1]): + raise BackendError("julia thread count must fit the initialized runtime") + self._engine = call_julia( + self._jl.create, _configuration(problem, self._threads) + ) + self._varying = _varying(problem) + if self._varying: + self._prepare_stages(0.0, 0.0) + self._plan_flag = str(getattr(self._engine.config, "plan_flag", "estimate")) + self._weight = ( + np.empty(0) + if problem.transform.geometry is not None + else power_weight_at(problem, 0.0) + ) + self._fsal = False + self._recycle = _responses_recycle(problem) + self._alarm = math.nan + self._alarm_reported = False + if isinstance(problem.stepper.integrator, LowStorageRungeKutta): + from solprop.backends.low_storage import LowStorageMarch # noqa: PLC0415 + + self._low_storage = LowStorageMarch(self, problem.stepper.integrator) + + if isinstance(problem.stepper.integrator, Multistep): + from solprop.backends.multistep import AdamsMarch # noqa: PLC0415 + + self._adams = AdamsMarch(self, problem.stepper.integrator) + + def _adams_state(self) -> Complex[np.ndarray, "n_batch n_modes n_pol n_omega"]: + """Copy the resident state for rare host persistence and budget reports.""" + return self._observed_field(self._require_state()) + + def _adams_restore( + self, z: float, state: Complex[np.ndarray, "n_batch n_modes n_pol n_omega"] + ) -> None: + """Restore a snapshot field before continuing its resident history.""" + self._state = self._apply_mask(state) + self._z = z + + def _adams_engine( + self, method: Multistep, compensation: Literal["transported", "untransported"] + ) -> object: + """Keep exponential samples in Julia behind the shared Adams controller.""" + from solprop.backends.julia._integrators import JuliaAdams # noqa: PLC0415 + + if compensation != "transported": + raise BackendError( + "julia does not support untransported Adams compensation" + ) + return JuliaAdams(self, method) + + def _low_storage_engine(self, method: LowStorageRungeKutta) -> object: + """Keep RK4IP registers in Julia and reuse the shared schedule march.""" + from solprop.backends.julia._integrators import JuliaRK4 # noqa: PLC0415 + + return JuliaRK4(self, method) + + def _apply_mask( + self, state: Complex[np.ndarray, "n_batch n_modes n_pol n_omega"] + ) -> object: + """Load and mask an initial field in Julia-owned storage. + + Parameters + ---------- + state : numpy.ndarray + Internal field with the canonical seam layout. + + Returns + ------- + object + Opaque Julia engine handle. + """ + call_julia(self._jl.load_b, self._engine, state[0, :, 0, :].T.copy()) + self._fsal = False + self._alarm = math.nan + return self._engine + + def set_initial( + self, + field: Complex[np.ndarray, "n_batch n_modes n_pol n_omega"], + noise: NoiseRealisation | None, + *, + z: float = 0.0, + resume: bool = False, + ) -> None: + """Load an owning field and reset the controller and FSAL cache. + + Parameters + ---------- + field : numpy.ndarray + Internal complex128 field of shape (1, n_modes, 1, n_omega). + noise : solprop.noise.NoiseRealisation or None + Must be None for this prototype. + z : float, optional + Initial position in metres. + resume : bool, optional + Whether `field` came back from a saved plane of this run. + + Raises + ------ + BackendError + If noise is supplied or the field is nonfinite. + """ + if noise is not None or not np.all(np.isfinite(field)): + raise BackendError("julia requires finite initial fields without noise") + super().set_initial(field, noise, z=z, resume=resume) + if self._adams is not None: + self._adams.reset() + + def _march_to(self, target: float) -> None: + """Dispatch adaptive and replayed Adams runs to the existing march.""" + if self._adams is None: + super()._march_to(target) + else: + self._adams.march_to(target) + + def _trial_step(self, z: float, dz: float) -> tuple[float, object]: + """Evaluate a trial without changing the accepted state. + + Parameters + ---------- + z : float + Start position, m, at which the existing stage tables are evaluated. + dz : float + Trial step length, m. + + Returns + ------- + float + Dimensionless controller error norm. + object + Opaque engine whose candidate buffer awaits acceptance. + + Raises + ------ + BackendError + If the trial produces a nonfinite norm or state is unavailable. + """ + self._require_state() + if self._varying: + self._prepare_stages(z, dz) + norm = float(call_julia(self._jl.trial_b, self._engine, dz, nogil=True)) + self._rk_source_evaluations += 6 if self._fsal else 7 + self._fsal = True + if not np.isfinite(norm): + raise BackendError("julia produced a nonfinite trial error norm") + return norm, self._engine + + def _prepare_stages(self, z: float, dz: float) -> None: + """Transfer only the existing seam's scalar bundles before a Julia trial.""" + problem = self._problem + nodes = problem.stepper.tableau.nodes + # Resident Adams reads only the first material row and endpoint flow/ + # material row. Retain the fixed buffer shape without evaluating unused + # DOPRI nodes; repeated positions (including dz=0) share a pure bundle. + offsets = ( + [0.0] * (len(nodes) - 1) + [dz] + if isinstance(problem.stepper.integrator, Multistep) + else [float(c) * dz for c in nodes] + ) + self._hoist(z) + bundles = self._stage_bundles(z, [z + offset for offset in offsets]) + kerr = problem.responses.kerr_coefficients + material = np.array( + [ + [ + 0.0 if kerr is None else kerr.coefficient * b.kerr_density, + b.plasma_densities[0] if b.plasma_densities else 0.0, + b.preionisation, + ] + for b in bundles + ] + ).T.copy() + deltas, prefactors = [], [] + for bundle in bundles: + assert bundle.phi_delta is not None and bundle.prefactor is not None + deltas.append(bundle.phi_delta) + prefactors.append(bundle.prefactor) + call_julia( + self._jl.configure_stages_b, + self._engine, + np.stack(deltas, axis=1), + np.stack(prefactors, axis=1), + material, + ) + + def _finish(self, state: object, dz: float) -> object: + """Commit the candidate and apply accepted-step boundary treatments. + + Parameters + ---------- + state : object + Opaque candidate handle returned by the trial. + dz : float + Accepted step length, m. + + Returns + ------- + object + Opaque accepted state handle. + """ + self._alarm = float(call_julia(self._jl.commit_b, self._engine, dz, nogil=True)) + if self._alarm > 1e-6 and not self._alarm_reported: + self._alarm_reported = True + logger.warning( + "transverse quadrature error %.2e exceeds 1e-6 at z=%.6g m; " + "refine the quadrature", + self._alarm, + self._z + dz, + ) + self._fsal = self._recycle + return state + + def _begin_plane(self) -> None: + """Reset the per-plane quadrature diagnostic's reporting flag.""" + self._alarm_reported = False + + def _observed_field( + self, state: object + ) -> Complex[np.ndarray, "n_batch n_modes n_pol n_omega"]: + """Copy an accepted state back to the canonical host layout. + + Parameters + ---------- + state : object + Opaque accepted state handle. + + Returns + ------- + numpy.ndarray + Independent complex128 host array in the seam layout. + """ + values = np.asarray(call_julia(self._jl.snapshot, state), dtype=np.complex128) + return values.T.copy()[None, :, None, :] + + def stats(self, spec: StatsSpec) -> dict[str, np.ndarray]: + """Collect supported modal or spatial statistics through shared host functions. + + Parameters + ---------- + spec : solprop.stats.StatsSpec + Supported statistic names and any periodic subset. + + Returns + ------- + dict + Owning host arrays, with the leading singleton batch axis. + + Raises + ------ + BackendError + If a requested statistic is not supported or no state is loaded. + """ + spatial = self._problem.transform.geometry is not None + _refuse_stats(spec, spatial=spatial) + if self._varying: + self._weight = power_weight_at(self._problem, self._z) + self._prepare_stages(self._z, 0.0) + state = self._observed_field(self._require_state())[0] + grid = self._require_grid() + if spatial: + delegated = dataclasses.replace( + spec, + names=tuple(n for n in spec.names if n not in _SPECIES_STATS), + periodic=(), + ) + values = collect_spatial( + delegated, + grid, + self._problem.transform, + state, + z=self._z, + flux=self._problem.flux, + profiles=self._profiles, + operator=self._problem.linear.separable, + ) + if _SPECIES_STATS.intersection(spec.names): + values.update(self._populations(spec, state)) + return {name: value[None] for name, value in values.items()} + weighted = not np.all(self._weight == 1.0) + owned = ( + (_POYNTING_STATISTICS if weighted else {"peak_intensity"}) + | _SPECIES_STATS + | {"quadrature_error"} + ) + delegated = dataclasses.replace( + spec, names=tuple(n for n in spec.names if n not in owned), periodic=() + ) + values = collect( + delegated, + grid, + SavedPlane(z=self._z, field=state), + modes=self._modes, + profiles=self._profiles, + ) + if weighted or "peak_intensity" in spec.names: + axis = None + if "peak_intensity" in spec.names: + if self._modes is None: + raise BackendError("julia peak_intensity requires modes") + axis = self._on_axis_synthesis(self._modes) + values.update(_poynting_statistics(spec, grid, state, self._weight, axis)) + if "quadrature_error" in spec.names: + values["quadrature_error"] = np.asarray(self._alarm) + if _SPECIES_STATS.intersection(spec.names): + values.update(self._populations(spec, state)) + return {name: value[None] for name, value in values.items()} + + def _populations(self, spec: StatsSpec, state: np.ndarray) -> dict[str, np.ndarray]: + """Reduce fresh accepted-field populations at an observation.""" + from solprop.backends.populations import population_statistics # noqa: PLC0415 + + parts = np.zeros(6) + if self._problem.flags.has_plasma: + raw = call_julia( + self._jl.population_snapshot, self._engine, state[:, 0, :].T.copy() + ) + fractions, peaks = (np.asarray(raw[i], dtype=float)[None] for i in (0, 1)) + parts = np.asarray(raw[2], dtype=float) + else: + fractions = peaks = np.zeros((0, self._problem.transform.n_nodes)) + values = population_statistics(self._problem, self._z, fractions, peaks) + if fractions.shape[0] == 1: + values["peak_ionisation_rate"] = np.asarray( + peaks[0, np.argmax(fractions[0])] + ) + if any(name.startswith("plasma_") for name in spec.names): + values.update( + zip( + ( + "plasma_undershoot", + "plasma_work_defect", + "plasma_boundary_level", + ), + ( + np.asarray(value) + for value in plasma_integration_statistics(parts) + ), + strict=True, + ) + ) + return {name: values[name] for name in spec.names if name in _SPECIES_STATS} + + def metadata(self) -> dict[str, object]: + """Return runtime and thread provenance beside the shared step counters. + + Returns + ------- + dict + JSON-serializable execution metadata, without local paths. + """ + self._check_open() + assert self._engine is not None + version, threads, fft, blas, library = self._jl.runtime() + config = self._engine.config + free = self._problem.transform.kind == "free" + return super().metadata() | { + "julia_version": str(version), + "julia_source_digest": source_digest(), + "device": str(self._jl.device_name(self._engine)), + "resident_source_evaluations": int(self._engine.calls), + "propagator_cache": ( + "schedule_run_mean" + if self._low_storage is not None + else "stage_expansion" + if self._varying + else "constant_table_exact_dz" + if self._propagator_mode == "tabulate" + else "disabled" + ), + "julia_threads": int(threads), + "fftw_threads": int(fft), + "modal_fftw_threads": int(config.fft_threads), + "raman_fftw_threads": int(config.raman_fft_threads) + if self._problem.flags.has_raman + else None, + "transverse_fftw_threads": int(config.transverse_fft_threads) + if free + else None, + "blas_threads": int(blas), + "blas_library": str(library), + "plan_flag": self._plan_flag, + "experimental": True, + } + + def memory_ledger(self) -> dict[str, int]: + """List owned numerical arrays, excluding opaque library plan internals. + + Returns + ------- + dict + Byte counts by Julia buffer name and host table. + """ + self._check_open() + result = self._jl.ledger(self._engine) + return {str(name): int(result[name]) for name in result} | ( + {"host_power_weight": self._weight.nbytes} if self._weight.size else {} + ) + + def close(self) -> None: + """Release this engine's Julia references; repeated calls are harmless.""" + self._state = None + self._engine = None + self._closed = True + self._rows.clear() + + +def _responses_recycle(problem: KernelProblem) -> bool: + """Decide whether accepted-step absorption preserves the last source. + + Parameters + ---------- + problem : solprop.translate.problem.KernelProblem + Constant modal or spatial contract. + + Returns + ------- + bool + Whether the source can be reused after acceptance. + """ + response = problem.responses + return ( + response.absorber_scheme != "split_step" + or response.temporal_absorber is None + or not np.any(response.temporal_absorber) + ) diff --git a/src/solprop/backends/julia/_integrators.py b/src/solprop/backends/julia/_integrators.py new file mode 100644 index 000000000..98be91096 --- /dev/null +++ b/src/solprop/backends/julia/_integrators.py @@ -0,0 +1,204 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Connect resident Julia integrators to the existing Python march policies.""" + +import math +from collections.abc import Mapping + +import numpy as np + +from solprop._helpers import PLAIN +from solprop.backends.julia._backend import JuliaBackend +from solprop.backends.julia._runtime import call_julia +from solprop.backends.low_storage import schedule_key, table_steps +from solprop.backends.multistep import compensation_tables, exponential_tables +from solprop.exceptions import BackendError +from solprop.stepper import LowStorageRungeKutta, Multistep +from solprop.translate.linop import rate_weights + + +class JuliaRK4: + """Own the small RK4IP policy while Julia holds all field registers.""" + + atomic = True + + def __init__(self, backend: JuliaBackend, method: LowStorageRungeKutta) -> None: + self.backend = backend + self.method = method + self.stiffness = math.nan + schedule = backend._problem.stepper.schedule + assert schedule is not None + self.keys = table_steps(schedule) + self.edges = schedule.edges + + def step(self, z: float, dz: float) -> float: + """Execute the four resident source passes and return the state norm.""" + backend = self.backend + key = schedule_key(self.keys, self.edges, z, dz) + squared, self.stiffness = call_julia( + backend._jl.rk4_b, backend._engine, dz, key, nogil=True + ) + return float(squared) + + def reset(self) -> None: + """Reset diagnostics after loading an initial state.""" + self.stiffness = math.nan + + def close(self) -> None: + """Release no arrays: the backend owns the resident registers.""" + self.reset() + + +class JuliaAdams: + """Keep exponential PEC samples resident and exchange only scalar trial tables.""" + + dense = None + # The carrier frame is refused at admission (SEP 35 is not delivered here). + carrier = None + + def __init__(self, backend: JuliaBackend, method: Multistep) -> None: + self.backend = backend + self.method = method + assert backend._engine is not None + self.compensated = bool(backend._engine.work.adams.compensated) + self._dz = 0.0 + + @property + def n_slots(self) -> int: + """Return the shared march's required history capacity.""" + return self.method.order + 2 + + def reset(self) -> None: + """Forget the pending trial; startup replaces the first resident row.""" + self._dz = 0.0 + + def start(self, z: float, *, stored: bool) -> None: + """Evaluate the accepted initial state's first source sample.""" + del stored + backend = self.backend + if backend._varying: + backend._prepare_stages(z, 0.0) + if self.compensated: + call_julia( + backend._jl.configure_adams_rate_b, + backend._engine, + rate_weights(backend._problem.linear, z, helpers=PLAIN), + ) + call_julia(backend._jl.adams_start_b, backend._engine, nogil=True) + + def value(self, slot: int) -> None: + """Keep history rows opaque to the march.""" + del slot + + def hold(self) -> object: + """Refuse dense observation, which admission already refuses.""" + raise BackendError("julia does not support interpolated Adams planes") + + def restore(self, z: float, held: object) -> None: + """Refuse dense observation, which admission already refuses.""" + del z, held + raise BackendError("julia does not support interpolated Adams planes") + + def observe(self, position: float) -> object: + """Refuse dense observation, which admission already refuses.""" + del position + raise BackendError("julia does not support interpolated Adams planes") + + def fused_trial(self, *args: object) -> np.ndarray: + """Refuse the interaction formulation, which admission already refuses.""" + del args + raise BackendError("julia runs the exponential Adams formulation only") + + def fused_accept(self, *args: object, **kwargs: object) -> None: + """Refuse the interaction formulation, which admission already refuses.""" + del args, kwargs + raise BackendError("julia runs the exponential Adams formulation only") + + def snapshot_nbytes(self) -> int: + """Return the bytes :meth:`snapshot_rows` would copy.""" + rows = 3 if self.compensated else 1 + return rows * self.n_slots * math.prod(self.backend._problem.shape) * 16 + + def exponential_trial( + self, + z: float, + dz: float, + nodes: list[float], + slots: np.ndarray, + order: int, + orders: list[int], + ) -> np.ndarray: + """Copy scalar tables, then run the resident trial without the GIL.""" + backend = self.backend + if backend._varying: + backend._prepare_stages(z, dz) + predictor, corrector, defects = exponential_tables( + nodes, order, orders, helpers=PLAIN + ) + spans = carried = endpoint = corrections = rate = np.empty(0) + if self.compensated: + spans, carried, endpoint, corrections = compensation_tables( + nodes, order, orders, helpers=PLAIN + ) + rate = rate_weights( + backend._problem.linear, z + dz, before=True, helpers=PLAIN + ) + call_julia( + backend._jl.configure_adams_b, + backend._engine, + predictor, + corrector, + defects, + slots[: corrector.shape[0] - 1], + spans, + carried, + endpoint, + corrections, + rate, + ) + result = call_julia(backend._jl.adams_trial_b, backend._engine, dz, nogil=True) + self._dz = dz + return np.asarray(result, dtype=float).copy() + + def exponential_accept( + self, keep: np.ndarray, free: int, *, interpolate: bool + ) -> None: + """Save the endpoint sample and commit the accepted candidate.""" + del keep + if interpolate: + raise BackendError("julia does not support interpolated Adams planes") + backend = self.backend + call_julia(backend._jl.adams_accept_b, backend._engine, free, nogil=True) + backend._state = backend._finish(backend._engine, self._dz) + + def snapshot_rows(self) -> dict[str, np.ndarray]: + """Copy owning history rows into the existing resume layout.""" + backend = self.backend + names = ("store", "states", "rates") if self.compensated else ("store",) + shape = (self.n_slots, *backend._problem.shape) + return { + name: np.asarray(call_julia(backend._jl.adams_rows, backend._engine, name)) + .transpose(2, 1, 0) + .copy() + .reshape(shape) + for name in names + } + + def load_rows(self, rows: Mapping[str, np.ndarray], shape: tuple[int, ...]) -> None: + """Validate all snapshot rows before replacing the resident history.""" + names = {"store", "states", "rates"} if self.compensated else {"store"} + expected = (self.n_slots, *shape) + if set(rows) != names or any( + row.shape != expected or row.dtype != np.complex128 for row in rows.values() + ): + raise BackendError("julia Adams history does not match the snapshot") + backend = self.backend + for name, row in rows.items(): + call_julia( + backend._jl.adams_load_rows_b, + backend._engine, + name, + row[:, 0, :, 0, :].transpose(2, 1, 0).copy(), + ) + self.reset() diff --git a/src/solprop/backends/julia/_runtime.py b/src/solprop/backends/julia/_runtime.py new file mode 100644 index 000000000..e7d0285ae --- /dev/null +++ b/src/solprop/backends/julia/_runtime.py @@ -0,0 +1,175 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Load the source checkout's private Julia runtime only on explicit selection.""" + +import functools +import hashlib +import os +import sys +from pathlib import Path +from typing import Any + +from solprop.exceptions import BackendError + +VERSION = "1.13.3" +"""The Julia release the experiment's manifest is resolved with.""" + + +def thread_limit(name: str, default: int = 1) -> int: + """Read a positive thread-pool limit from an environment variable. + + Parameters + ---------- + name : str + Environment variable to read. + default : int, optional + Limit when the variable is absent. + + Returns + ------- + int + Positive thread count. + + Raises + ------ + BackendError + If the value is not a positive integer. + """ + try: + value = int(os.environ.get(name, str(default))) + if value < 1: + raise ValueError(name) + except ValueError as exc: + raise BackendError(f"{name} must be a positive integer") from exc + return value + + +def call_julia(function: Any, *args: object, nogil: bool = False) -> Any: + """Translate bridge failures at the dynamic JuliaCall boundary. + + Parameters + ---------- + function : object + JuliaCall function wrapper. + *args : object + Arguments accepted by the Julia function. + nogil : bool, optional + Release the GIL only for pure Julia numerical work. + + Returns + ------- + object + Converted result or opaque Julia handle. + + Raises + ------ + BackendError + If Julia or the bridge raises an exception; the cause is retained. + """ + try: + return function._jl_call_nogil(*args) if nogil else function(*args) + except Exception as exc: + raise BackendError(f"julia execution failed: {exc}") from exc + + +# JuliaCall exposes dynamically compiled Julia modules, so Any is confined to its +# boundary. Numerical arrays are converted to owned NumPy arrays by the adapter. +@functools.cache +def runtime() -> Any: + """Load the experimental Julia module from this source checkout. + + ``SOLPROP_JULIA_EXE`` names the Julia 1.13 executable (default: the one + ``julia/bootstrap.py`` downloads) and ``SOLPROP_JULIA_DEPOT`` its package depot + (default ``.julia-depot``). ``SOLPROP_JULIA_DEVICE=cuda`` loads CUDA.jl first, so + that the engine's CUDA extension is available. + + Returns + ------- + object + JuliaCall's dynamically compiled module wrapper. + + Raises + ------ + BackendError + If the runtime or Julia project has not been prepared. + """ + root = Path(__file__).resolve().parents[4] + if "juliacall" in sys.modules: + raise BackendError( + "julia requires a fresh Python process: JuliaCall was already initialized" + ) + executable = Path( + os.environ.get( + "SOLPROP_JULIA_EXE", str(root / f".julia-runtime/julia-{VERSION}/bin/julia") + ) + ) + project = root / "julia" + if not executable.is_file() or not (project / "Manifest.toml").is_file(): + raise BackendError( + "julia requires a source checkout with a prepared Julia 1.13 runtime; " + "follow julia/README.md" + ) + settings = { + "PYTHON_JULIACALL_EXE": str(executable), + "PYTHON_JULIACALL_PROJECT": str(project), + "PYTHON_JULIACALL_STARTUP_FILE": "no", + "PYTHON_JULIACALL_HANDLE_SIGNALS": "yes", + "PYTHON_JULIACALL_THREADS": str(thread_limit("SOLPROP_JULIA_THREADS")), + "JULIA_DEPOT_PATH": os.environ.get( + "SOLPROP_JULIA_DEPOT", str(root / ".julia-depot") + ), + "JULIA_CONDAPKG_BACKEND": "Null", + } + device = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") + if device not in {"cpu", "cuda"}: + raise BackendError("SOLPROP_JULIA_DEVICE must be cpu or cuda") + # The CUDA packages live in a second environment stacked on the project's, so a + # CPU run never resolves or loads them. + settings["JULIA_LOAD_PATH"] = ( + f"@:{project / 'cuda'}:@stdlib" if device == "cuda" else "@:@stdlib" + ) + # The experiment deliberately owns one Julia runtime per Python process. + for name, value in settings.items(): + if name in os.environ and os.environ[name] != value: + raise BackendError(f"julia runtime conflicts with {name}") + os.environ[name] = value + import juliacall # noqa: PLC0415 - Julia must never initialize on package import + + module = juliacall.newmodule("SolpropBackend") + if device == "cuda": + call_julia(module.seval, "using CUDA") + digest = source_digest() + call_julia(module.seval, "using SolpropJulia") + module.SolpropJulia.record_digest(digest) + return module.SolpropJulia + + +def source_digest() -> str: + """Return a SHA-256 over the Julia sources, the manifest and this adapter. + + The experiment's counterpart of a native build's source digest: it names exactly + what a timing ran, and the engine refuses to run if its loaded module's digest + differs from the files on disk. + + Returns + ------- + str + Hexadecimal digest. + """ + root = Path(__file__).resolve().parents[4] + paths = sorted( + [ + *(root / "julia/src").rglob("*.jl"), + *(root / "julia/ext").rglob("*.jl"), + root / "julia/Project.toml", + root / "julia/Manifest.toml", + *Path(__file__).parent.glob("*.py"), + ] + ) + digest = hashlib.sha256() + for path in paths: + if path.is_file(): + digest.update(str(path.relative_to(root)).encode()) + digest.update(path.read_bytes()) + return digest.hexdigest() diff --git a/src/solprop/backends/registry.py b/src/solprop/backends/registry.py index 46595d192..6441b5e7f 100644 --- a/src/solprop/backends/registry.py +++ b/src/solprop/backends/registry.py @@ -83,6 +83,8 @@ class BackendEntry: "native": BackendEntry(requires=("solprop_native",), extras=()), # Apple-silicon GPUs through MLX, single precision only (SEP 33). "mlx": BackendEntry(requires=("mlx",), extras=("mlx",)), + # The Julia experiment: CPU, or NVIDIA GPU with SOLPROP_JULIA_DEVICE=cuda. + "julia": BackendEntry(requires=("juliacall",), extras=("julia",)), } """The backends this package knows, by name.""" @@ -683,4 +685,8 @@ def _construct( from solprop.backends.mlx_gpu.backend import MlxBackend # noqa: PLC0415 return MlxBackend(problem, grid=grid, modes=modes, profiles=profiles) + if name == "julia": # pragma: no cover - needs the Julia experiment's runtime + from solprop.backends.julia import JuliaBackend # noqa: PLC0415 + + return JuliaBackend(problem, grid=grid, modes=modes, profiles=profiles) raise AssertionError(f"unhandled backend registry entry {name!r}") diff --git a/src/solprop/driver/simulation.py b/src/solprop/driver/simulation.py index abe17c145..c46c8633f 100644 --- a/src/solprop/driver/simulation.py +++ b/src/solprop/driver/simulation.py @@ -1315,7 +1315,7 @@ def _stepper_record(settings: StepperSettings) -> StepperRecord: ) -LOW_STORAGE_BACKENDS = ("native", "numpy_ref") +LOW_STORAGE_BACKENDS = ("native", "numpy_ref", "julia") """The backends that execute :class:`~solprop.stepper.low_storage.LowStorageRungeKutta`. ``numpy_ref`` from SEP 24's phase 1 and solprop-native from phase 3, on every route the @@ -1394,10 +1394,10 @@ def _admit_integrator(integrator: Multistep, backend: str) -> None: DriverError Naming the conflict and the Runge-Kutta march every backend executes. """ - if backend not in ("auto", "numpy_ref", "native", "mlx"): + if backend not in ("auto", "numpy_ref", "native", "mlx", "julia"): msg = ( - f"the {integrator.name} integrator is implemented on numpy_ref, native " - f"and mlx only, and backend {backend!r} would step the problem with its " + f"the {integrator.name} integrator is implemented on numpy_ref, native, " + f"mlx and julia only, and backend {backend!r} would step the problem with its " "Runge-Kutta march; pass one of those or 'auto', or " "integrator=RungeKutta()" ) diff --git a/uv.lock b/uv.lock index 417d617ce..a9c40d9d4 100644 --- a/uv.lock +++ b/uv.lock @@ -615,6 +615,33 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, ] +[[package]] +name = "juliacall" +version = "0.9.37" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "juliapkg" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/8e/bf4fdb7bcb077747ba0031bea51023e559476c0ab7fc8ba8ea0d59a608eb/juliacall-0.9.37.tar.gz", hash = "sha256:246db2ec648cd50dcd446d02323e0b187949a2ab50e06e32fe6db1a4323eba75", size = 502805, upload-time = "2026-10-19T19:03:30.597Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/fc/97ba79312c411bb25e31ea460b7080b2da932c884086967e5d06ddf80107/juliacall-0.9.37-py3-none-any.whl", hash = "sha256:e8413f2081e77c04a4ba379bdb93620c0753bd7bc335127773c318ce3526b1b9", size = 12774, upload-time = "2026-10-19T19:03:29.144Z" }, +] + +[[package]] +name = "juliapkg" +version = "0.1.28" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "semver" }, + { name = "tomli" }, + { name = "tomlkit" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ce/b1/965f7b066df488d7328fb448cf09b5647d2958266742e8e124239135c9fb/juliapkg-0.1.28.tar.gz", hash = "sha256:24f3ca545263e090f57521f47900bbb94ee7ebc9d91c55c82e4148aaf1b58e36", size = 27403, upload-time = "2026-10-24T21:24:35.341Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/18/5b8ebec81b05ce0bf355118992cdb94a97cdfe19e60662f99e2059e61b73/juliapkg-0.1.28-py3-none-any.whl", hash = "sha256:e09640eb5d3465eda0ea40fda912048cc06f34e1a3880eb9e46f4e2c836d8d48", size = 23609, upload-time = "2026-10-24T21:24:34.26Z" }, +] + [[package]] name = "kiwisolver" version = "1.5.1" @@ -1534,6 +1561,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/12/11/263ced30149fbede00614a11f01de792842d3636b5a9e3abfee34e764a0e/scipy_stubs-1.18.1.0-py3-none-any.whl", hash = "sha256:fc1f00da3eb6bf1adf2138774b5e6a91dcf7c77039ff199577dc47929c10793e", size = 653731, upload-time = "2026-08-22T09:22:51.43Z" }, ] +[[package]] +name = "semver" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/f5/e1dfe8e1d91c54ce212fd93916eb01fd1c590f413be0a0978c39a97aa1bb/semver-3.1.0.tar.gz", hash = "sha256:14bc073439513d7773662a338f4db9829cf16c12b74b9568e2d2689975fbd7fc", size = 304162, upload-time = "2026-09-12T18:38:14.045Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/02/bce7a1d70e9d0f6ea8623c16386138c251b5855af6cd3a11433d3fba4e66/semver-3.1.0-py3-none-any.whl", hash = "sha256:6e4998f8b4762acdfea85f9bfd5b4032e0bb50038dc04bf82011b42d5d1145c5", size = 18783, upload-time = "2026-09-12T18:38:12.457Z" }, +] + [[package]] name = "setuptools" version = "84.2.1" @@ -1607,6 +1643,9 @@ dependencies = [ gui = [ { name = "solprop-gui" }, ] +julia = [ + { name = "juliacall" }, +] mlx = [ { name = "mlx", marker = "platform_machine == 'arm64' and sys_platform == 'darwin'" }, ] @@ -1649,6 +1688,7 @@ gui-test = [ requires-dist = [ { name = "h5py", specifier = ">=3.15" }, { name = "jaxtyping", specifier = ">=0.3.11" }, + { name = "juliacall", marker = "extra == 'julia'", specifier = "==0.9.37" }, { name = "matplotlib", specifier = ">=3.10.7" }, { name = "mlx", marker = "platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'mlx'", specifier = ">=0.32.4,<0.33" }, { name = "numpy", specifier = ">=2.5" }, @@ -1660,7 +1700,7 @@ requires-dist = [ { name = "tomli-w", specifier = ">=1.0" }, { name = "tqdm", specifier = ">=4.67" }, ] -provides-extras = ["gui", "mlx"] +provides-extras = ["gui", "julia", "mlx"] [package.metadata.requires-dev] dev = [ @@ -1854,6 +1894,51 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" }, ] +[[package]] +name = "tomli" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/78/9ad63712633ed3ab5cc1a648d863d7e7da371e9425e209555a0fe711b695/tomli-2.5.0.tar.gz", hash = "sha256:264507556cd8b8c8e7c6ee037cdf443a463f03f4c958e57195e3d369711b8ff6", size = 17662, upload-time = "2026-10-07T12:23:37.892Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/49/caf6b307766eb9567664a8707e9d6be5fcc0e8903f18781c6677a60d80c7/tomli-2.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d3182ee2d887e507bd67319a0a61105d1dd33facc111329559a233b772c1a105", size = 162899, upload-time = "2026-10-07T12:22:50.088Z" }, + { url = "https://files.pythonhosted.org/packages/d3/c8/68cfce773a2733a49c74f99d627fb461bd990756860099eac25617889585/tomli-2.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:521345fd1f19d45b8df87657aaa38b6f2ca3800059fadf428e7ebf479a383646", size = 162080, upload-time = "2026-10-07T12:22:51.558Z" }, + { url = "https://files.pythonhosted.org/packages/7e/b2/e5bb8651fdad593f670501a7d718b1a7f73f064d44dea15e04c04dfef45d/tomli-2.5.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e95c7614e705bfe2b04b27aa124adec59752d15813df37e2156747cab3a006b", size = 273380, upload-time = "2026-10-07T12:22:52.918Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d2/9e2d7f8b1dfe0e2b34c245986ebd55c4c553ea4ce6c47c443b332673253f/tomli-2.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ac2027d37c3afbdf4bdd377f2676f6f1d2122a5be1f1137b49dced590b37e75", size = 283228, upload-time = "2026-10-07T12:22:54.173Z" }, + { url = "https://files.pythonhosted.org/packages/ba/df/ec7b876b7b1a2718bd74a3743c076fff565b04029ba33e8f61fac262739f/tomli-2.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c414be4ed9d3cac80c42e348fa5a956117d1a48227f48026e31f59cb4a7671eb", size = 277189, upload-time = "2026-10-07T12:22:55.342Z" }, + { url = "https://files.pythonhosted.org/packages/7d/7b/e192d9eed0b9cb80da799f4d77052297fb9a2c3cc9b19f571f56ea88add6/tomli-2.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9b03d7dc168353b4132965bde20feceabaa470e570c6f59660dfae59b1f9eeb3", size = 283632, upload-time = "2026-10-07T12:22:56.735Z" }, + { url = "https://files.pythonhosted.org/packages/84/50/ff94454e75461d75623e47401ed323d65c10aab8fe9033242c20cd2fdf32/tomli-2.5.0-cp314-cp314-win32.whl", hash = "sha256:6f041843c4d3a37245c0c056fd955b186bf8b1fb85690cbe40b81230891dc34b", size = 103535, upload-time = "2026-10-07T12:22:58.084Z" }, + { url = "https://files.pythonhosted.org/packages/54/0b/bdacf05f963bd6026ebf6eeb0beda847d1d60e03e440725c64a4e08a0afd/tomli-2.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:f4b653094e18f9031102d3a1da5c729c8f222d85225b18037dac621695e46e1a", size = 114621, upload-time = "2026-10-07T12:22:59.2Z" }, + { url = "https://files.pythonhosted.org/packages/61/99/53f438fa6ae4f9d4ed0ddde3e7242b3bdc34b48c8f9948b72b9e9b127676/tomli-2.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:3f89d10c1ff6a38d992c27fc8a4816af71a909e08a40ec66934240b1e74347c3", size = 111572, upload-time = "2026-10-07T12:23:00.479Z" }, + { url = "https://files.pythonhosted.org/packages/b9/20/1f88f19427d380a40e90a770e087489eaafe4aeee070ae88ed2bbec00acd/tomli-2.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:e9e15b4a6c7dd6b85b5fbab29488a73f1f70de516942308daa266bf0e0aeb0d4", size = 171814, upload-time = "2026-10-07T12:23:01.914Z" }, + { url = "https://files.pythonhosted.org/packages/d0/56/cbe5079c9f9a54b9b3e27fc82f08f3cb36edee75561679f53d2380c801d6/tomli-2.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e12bbcd32897272fb05929110362ae9ff4c1b9bb26bd9e971e71dcd3275b4c3d", size = 171324, upload-time = "2026-10-07T12:23:03.18Z" }, + { url = "https://files.pythonhosted.org/packages/2b/30/1d53fd3b0f1cb3ba542e345ec32c26aefdddc4e829e4f3429af8a4f27782/tomli-2.5.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20aa36de8f2cf87237143bc1fa1aae8d6612c09118f4da21c6a684db5dd1f6f9", size = 297441, upload-time = "2026-10-07T12:23:04.345Z" }, + { url = "https://files.pythonhosted.org/packages/66/d9/0800acb6a111686f764c1b91ef15cc42a20a66a46013bb42220f1d2c61c1/tomli-2.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22185fad8a1e622f064e78008018a0dd3323550dcb479cb7a1d296888d74024f", size = 307476, upload-time = "2026-10-07T12:23:05.671Z" }, + { url = "https://files.pythonhosted.org/packages/e8/63/30a8f3cd51b5bec37f04744bad0b0dc6160df84aad4f27b0e9283d66f221/tomli-2.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:984012f71908165449a951de2050d52f276bfe3aa5d5f570f63ddad814370374", size = 296113, upload-time = "2026-10-07T12:23:07.202Z" }, + { url = "https://files.pythonhosted.org/packages/ab/18/0b9ffc597e69c5a1e20a7823cb60d54b39a9f54e91edcb8574f022186758/tomli-2.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f79203b3965b4000e91808aaa7c040206093f2b8bf86f455982f2274c9ccf442", size = 307725, upload-time = "2026-10-07T12:23:08.508Z" }, + { url = "https://files.pythonhosted.org/packages/ab/c7/18f8baae0b5607a60e8e19b4a7fedee43a8ff6458e3896dcbbadeeac9c22/tomli-2.5.0-cp314-cp314t-win32.whl", hash = "sha256:91294a9fb94a75542f6e46e4a2ae709bd8d9b51134098cae5cf3bea5478b6d03", size = 108546, upload-time = "2026-10-07T12:23:09.956Z" }, + { url = "https://files.pythonhosted.org/packages/72/34/4cca9739254130627bde87500b3f2b512154fe2f278efa7e2a5e10ad4bcb/tomli-2.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f15e3e0b835a6d68b10c86bf80a3149780498d6911c93c3ffd1861d19f9200f1", size = 117814, upload-time = "2026-10-07T12:23:11.486Z" }, + { url = "https://files.pythonhosted.org/packages/7d/fb/afa530d47dd80a78fce43beac6bc6e00f84558eafcffbc6f37b21e80d056/tomli-2.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6664b7ae7af7294256c53960a6103077f4914cec8ff98479c352f622c6f6b2f0", size = 115188, upload-time = "2026-10-07T12:23:12.728Z" }, + { url = "https://files.pythonhosted.org/packages/66/98/316fdc00f8c0939e6fe50461dd343c162d3ad51d1286eb25b7db54361d50/tomli-2.5.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a525685c2f97da40762b8695eb7aa0af4c8344ca1905c73e4e29cb04d34607dc", size = 162775, upload-time = "2026-10-07T12:23:13.941Z" }, + { url = "https://files.pythonhosted.org/packages/c5/22/7b10fa5bb01c9539f53f69b619361b19350acc73657772ea7ac70ba309a8/tomli-2.5.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:9dbb18c1cfb2f6517942fc9314437f66aa06d94436ffb1f06102ef3572f35276", size = 161406, upload-time = "2026-10-07T12:23:15.215Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e7/1a069d86dfd20f1f84f71c63faed9f83c1d890bc06c27d82dc7d888fb573/tomli-2.5.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:752e8b1aa6a4367ef8bf6a1a1e005540f7ed055ba36d7193796812ca5404eb52", size = 273855, upload-time = "2026-10-07T12:23:16.471Z" }, + { url = "https://files.pythonhosted.org/packages/ae/83/d1ef43d1687d092ab9c235455c76e6e709483b346b056f086095c7c263a5/tomli-2.5.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c47300f9bf791808f77d82747691c4bb09cb14bdf3060cca99b42cdc4361d5a7", size = 284910, upload-time = "2026-10-07T12:23:18.166Z" }, + { url = "https://files.pythonhosted.org/packages/cc/05/f4d9cf7de61822ece0c3873f30d291e324911c71a378b8bfe5ced13fd9f5/tomli-2.5.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:19b0dd8749f4ea2f112c5fcfb3c5248390c899d7e2e173f1d91abee1fa0ff391", size = 277723, upload-time = "2026-10-07T12:23:19.355Z" }, + { url = "https://files.pythonhosted.org/packages/42/28/78262493141fa543151cf005760c3cb01d09fc28a11f993c05109902cb8c/tomli-2.5.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:57b1c3b01fab802e2899bc3d168dca320e14165e2fd9fd584760fb4ca5826859", size = 285115, upload-time = "2026-10-07T12:23:20.698Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b9/e1dab9a30bcb677b5cc5cee810609cfd64f24306a3055767dd3fda00b1e0/tomli-2.5.0-cp315-cp315-win32.whl", hash = "sha256:667e521b37a6c5ccaa044202c235b530f90177ffe2cd4a64ecc213c7dd535feb", size = 103475, upload-time = "2026-10-07T12:23:21.941Z" }, + { url = "https://files.pythonhosted.org/packages/4c/bd/31a3790c11d6ea95fcf5e6022ac0f8d0543c9b61120b730fc481bd43d3b4/tomli-2.5.0-cp315-cp315-win_amd64.whl", hash = "sha256:d747252933c8a65ef6bd8da0fbb7ce28a90eb6119d8cd00772cd528aa07b68d5", size = 114589, upload-time = "2026-10-07T12:23:23.098Z" }, + { url = "https://files.pythonhosted.org/packages/47/a2/4f6310fa699364f0e3af7ee3af88dddd9af066d33e716a0265bbe2b3ea84/tomli-2.5.0-cp315-cp315-win_arm64.whl", hash = "sha256:75dbcde8751b0a960aa3de173aa5e894d590755c6d7758b7e774c06f1dc3cbdd", size = 111493, upload-time = "2026-10-07T12:23:24.233Z" }, + { url = "https://files.pythonhosted.org/packages/68/14/00853f0b396d8971107ae1921bb5b322fdee1650d2f16bf06c20adb532e5/tomli-2.5.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:2419c2a189551987b59d80e63ec355671283336f41c6b9b89462df679c7d0c57", size = 171380, upload-time = "2026-10-07T12:23:25.512Z" }, + { url = "https://files.pythonhosted.org/packages/89/ad/fa6949321dadee46b27363974fb197b94c911c3b0f7a5fd26d7dc18fc2a0/tomli-2.5.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0dc598040da8d42cf20f0be588ed7004f46db12a0ac6c32e03a59dccedaaadcd", size = 170553, upload-time = "2026-10-07T12:23:26.855Z" }, + { url = "https://files.pythonhosted.org/packages/53/aa/3056c919eb3e084df3752b2cf5f865dcc04af0b27dba2f66d7b28af4633a/tomli-2.5.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49096930c8d886c9bbdab62d2d0d17ce823ddeea522309a190b36245d5b49e01", size = 294428, upload-time = "2026-10-07T12:23:28.132Z" }, + { url = "https://files.pythonhosted.org/packages/96/b2/faeeb5d8769ea3832021d73e892c8391eae7b4b4f8b55a789127bd8b18a9/tomli-2.5.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8ade5023067f99fe72b88accd30d0ea05a158e9e32a11f124e731ea9695313f", size = 304909, upload-time = "2026-10-07T12:23:29.381Z" }, + { url = "https://files.pythonhosted.org/packages/f6/52/f094c09e73fb654b621716d019acb5d29bdfd1be01df80c281d552bda48d/tomli-2.5.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b69564772b5c8f22ea5f498dff08cfa825045b4d4c4400529000bdf818aa3b2a", size = 293220, upload-time = "2026-10-07T12:23:30.608Z" }, + { url = "https://files.pythonhosted.org/packages/86/f5/0c30541078ca4b505ce3bd76ed931facbfec524dd018535d691d1af0a6d2/tomli-2.5.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:8ff3a2ca028c7eee0c777f9a092038d0a594a9fa04e215f929a22c329e2cb142", size = 305705, upload-time = "2026-10-07T12:23:32.181Z" }, + { url = "https://files.pythonhosted.org/packages/05/74/590e7d19d6a118fc5cc5704ff358e21d95b8573f6b9443b1519f29ca8825/tomli-2.5.0-cp315-cp315t-win32.whl", hash = "sha256:62fc1bc8eb03e3a9cadfca713d65614ed8e09d974a283295ffe3a831976b4dc5", size = 108432, upload-time = "2026-10-07T12:23:33.496Z" }, + { url = "https://files.pythonhosted.org/packages/1c/b8/63a75cfb27a17c38550e44025d3a6e7be64516fd8608a3b75703bf37d81b/tomli-2.5.0-cp315-cp315t-win_amd64.whl", hash = "sha256:f3fcbc57b1791fa6cbe5d8434179d51de12be1a4811469529f47f6e7487a2571", size = 117281, upload-time = "2026-10-07T12:23:34.648Z" }, + { url = "https://files.pythonhosted.org/packages/72/01/e8c1debb2173973372934c68fc8e46170ab60ef23ed4592dff4dec6e8993/tomli-2.5.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d2ba24db8a9376921b5e87b4762b9adb0f3f1deaea68f2b8b0bb2c11efb9c3e7", size = 115069, upload-time = "2026-10-07T12:23:35.77Z" }, + { url = "https://files.pythonhosted.org/packages/60/3f/3e3f8fd0919249b0200c80fbc4f9a1e70be19f9883da71dfb7f8b9ab8aca/tomli-2.5.0-py3-none-any.whl", hash = "sha256:32a7b79ac57a2e83670ce329ccf675798bc5a2094783a63676866b70503f2e2b", size = 14765, upload-time = "2026-10-07T12:23:36.875Z" }, +] + [[package]] name = "tomli-w" version = "1.2.0" From d46a85a5b5968ac26ee31890220f1049de20665f Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 13:22:53 +0000 Subject: [PATCH 002/107] Julia: read the split collar's sums and the transverse edge [skip ci] The boundary monitor's split-step reading and SEP 44's transverse edge go through the driver's host reductions, so every focus case now takes the same steps as native. Co-Authored-By: Claude Opus 5.5 --- julia/bench/Manifest.toml | 858 +++++++++++++++++++++++++ julia/bench/Project.toml | 6 + julia/bench/launch.jl | 79 +++ src/solprop/backends/julia/_backend.py | 18 + 4 files changed, 961 insertions(+) create mode 100644 julia/bench/Manifest.toml create mode 100644 julia/bench/Project.toml create mode 100644 julia/bench/launch.jl diff --git a/julia/bench/Manifest.toml b/julia/bench/Manifest.toml new file mode 100644 index 000000000..685fda506 --- /dev/null +++ b/julia/bench/Manifest.toml @@ -0,0 +1,858 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "e1d577ebc9294ccc85c82473e39d27b364d15f68" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"] +git-tree-sha1 = "8c0bc12397dabf5d2dfc4b5763ec463854cc44d3" +registries = "General" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.46" + + [deps.Accessors.extensions] + AxisKeysExt = "AxisKeys" + IntervalSetsExt = "IntervalSets" + LinearAlgebraExt = "LinearAlgebra" + StaticArraysExt = "StaticArrays" + StructArraysExt = "StructArrays" + TestExt = "Test" + UnitfulExt = "Unitful" + + [deps.Accessors.weakdeps] + AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + +[[deps.BangBang]] +deps = ["Accessors", "ConstructionBase", "InitialValues", "LinearAlgebra"] +git-tree-sha1 = "cceb62468025be98d42a5dc581b163c20896b040" +registries = "General" +uuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66" +version = "0.4.9" + + [deps.BangBang.extensions] + BangBangChainRulesCoreExt = "ChainRulesCore" + BangBangDataFramesExt = "DataFrames" + BangBangStaticArraysExt = "StaticArrays" + BangBangStructArraysExt = "StructArrays" + BangBangTablesExt = "Tables" + BangBangTypedTablesExt = "TypedTables" + + [deps.BangBang.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BenchmarkTools]] +deps = ["Compat", "JSON", "Logging", "PrecompileTools", "Printf", "Profile", "Statistics", "UUIDs"] +git-tree-sha1 = "9670d3febc2b6da60a0ae57846ba74670290653f" +registries = "General" +uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +version = "1.8.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.ChunkSplitters]] +git-tree-sha1 = "1c52c8e2673edc030191177ff1aee42d25149acb" +registries = "General" +uuid = "ae650224-84b6-46f8-82ea-d812ca08434e" +version = "3.2.0" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CompositionsBase]] +git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" +registries = "General" +uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b" +version = "0.1.2" +weakdeps = ["InverseFunctions"] + + [deps.CompositionsBase.extensions] + CompositionsBaseInverseFunctionsExt = "InverseFunctions" + +[[deps.ConstructionBase]] +git-tree-sha1 = "b4b092499347b18a015186eae3042f72267106cb" +registries = "General" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.6.0" + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseLinearAlgebraExt = "LinearAlgebra" + ConstructionBaseStaticArraysExt = "StaticArrays" + + [deps.ConstructionBase.weakdeps] + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.InitialValues]] +git-tree-sha1 = "4da0f88e9a39111c2fa3add390ab15f3a44f3ca3" +registries = "General" +uuid = "22cec73e-a1b8-11e9-2c92-598750a2cf9c" +version = "0.3.1" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.InverseFunctions]] +git-tree-sha1 = "5cc6ad3e2bfc75a11eed92632ee341d37f4a4536" +registries = "General" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.18" + + [deps.InverseFunctions.extensions] + InverseFunctionsDatesExt = "Dates" + InverseFunctionsTestExt = "Test" + + [deps.InverseFunctions.weakdeps] + Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + + [deps.LLVM.weakdeps] + BFloat16s = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.OhMyThreads]] +deps = ["BangBang", "ChunkSplitters", "ScopedValues", "StableTasks", "TaskLocalValues"] +git-tree-sha1 = "a73a90d87e3f941f5084d34d56934c2fb59dd9b1" +registries = "General" +uuid = "67456a42-1dca-4109-a031-0a68de7e3ad5" +version = "0.8.9" + + [deps.OhMyThreads.extensions] + MarkdownExt = "Markdown" + ProgressMeterExt = "ProgressMeter" + + [deps.OhMyThreads.weakdeps] + Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" + ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.Profile]] +deps = ["StyledStrings"] +uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" +version = "1.11.0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "6aaddfdf3040d02a5b3e10c6cd0e4e1dce27f23c" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+1" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.StableTasks]] +git-tree-sha1 = "c4f6610f85cb965bee5bfafa64cbeeda55a4e0b2" +registries = "General" +uuid = "91464d47-22a1-43fe-8b7f-2d57ee82463f" +version = "0.1.7" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + + [deps.Statistics.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TaskLocalValues]] +git-tree-sha1 = "67e469338d9ce74fc578f7db1736a74d93a49eb8" +registries = "General" +uuid = "ed4db957-447d-4319-bfb6-7fa9ae7ecf34" +version = "0.1.3" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/bench/Project.toml b/julia/bench/Project.toml new file mode 100644 index 000000000..89be2e44a --- /dev/null +++ b/julia/bench/Project.toml @@ -0,0 +1,6 @@ +[deps] +AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +OhMyThreads = "67456a42-1dca-4109-a031-0a68de7e3ad5" +Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" diff --git a/julia/bench/launch.jl b/julia/bench/launch.jl new file mode 100644 index 000000000..80a5091db --- /dev/null +++ b/julia/bench/launch.jl @@ -0,0 +1,79 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Time one pointwise body under each CPU launch strategy the engine could use. +# Run: julia -t N --project=julia/bench julia/bench/launch.jl +using BenchmarkTools, Polyester, OhMyThreads +import AcceleratedKernels as AK +import KernelAbstractions as KA + +@inline kerr(v, f, w) = f * (v * v) * v * w + +function serial!(out, x, w, f) + @inbounds for m in axes(out, 2) + @simd for t in axes(out, 1) + out[t, m] = kerr(x[t, m], f, w[t]) + end + end +end + +# Flat blocks of contiguous samples: the same work split for any column count. +const BLOCK = 16384 +@inline function block!(out, x, w, f, b) + nt = size(out, 1) + first, last = (b - 1) * BLOCK + 1, min(b * BLOCK, length(out)) + @inbounds @simd for i in first:last + t = i - ((i - 1) ÷ nt) * nt + out[i] = kerr(x[i], f, w[t]) + end +end +function ak!(out, x, w, f) + AK.foreachindex(1:cld(length(out), BLOCK); min_elems=1) do b + block!(out, x, w, f, b) + end +end +function poly!(out, x, w, f) + @batch for b in 1:cld(length(out), BLOCK) + block!(out, x, w, f, b) + end +end +function static!(out, x, w, f) + Threads.@threads :static for b in 1:cld(length(out), BLOCK) + block!(out, x, w, f, b) + end +end +function omt!(out, x, w, f) + tforeach(1:cld(length(out), BLOCK); scheduler=:static) do b + block!(out, x, w, f, b) + end +end +# Column-blocked with a contiguous inner loop (the prototype's host traversal). +function columns!(out, x, w, f) + AK.foreachindex(axes(out, 2); min_elems=max(1, cld(32768, size(out, 1)))) do m + @inbounds @simd for t in axes(out, 1) + out[t, m] = kerr(x[t, m], f, w[t]) + end + end +end +KA.@kernel function kerr_kernel!(out, @Const(x), @Const(w), f) + t, m = KA.@index(Global, NTuple) + @inbounds out[t, m] = kerr(x[t, m], f, w[t]) +end +function ka!(out, x, w, f) + kerr_kernel!(KA.CPU(), 1024)(out, x, w, f; ndrange=size(out)) + KA.synchronize(KA.CPU()) +end +broadcast!(out, x, w, f) = (out .= kerr.(x, f, w); nothing) + +for (nt, nm) in ((10240, 4), (20480, 64), (10240, 1024)) + x, w = randn(nt, nm), rand(nt) + out = similar(x) + println("size $nt x $nm, threads $(Threads.nthreads())") + for (name, f!) in (("serial", serial!), ("broadcast", broadcast!), ("ak-flat", ak!), + ("polyester", poly!), ("threads", static!), ("ohmythreads", omt!), + ("ak-columns", columns!), ("ka-cpu", ka!)) + t = @belapsed $f!($out, $x, $w, 0.5) + println(rpad(" $name", 16), round(t * 1e6; digits=1), " us ", + round(16e-9 * length(out) / t; digits=1), " GB/s") + end +end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 82d73e861..b25277a6c 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -419,6 +419,8 @@ class JuliaBackend(StepDriver[object]): # and complete propagation trials stay in Julia. helpers = PLAIN propagator_default = "tabulate" + # The transverse edge (SEP 40/44) is read by the driver's host reduction. + reads_transverse_edge = True def __init__( self, @@ -638,6 +640,14 @@ def _finish(self, state: object, dz: float) -> object: object Opaque accepted state handle. """ + if (monitor := self._split_monitor) is not None and _splits(self._problem): + # What the split collar takes and finds, from the masked state before + # it, as the reference's finish reads it (SEP 21). + values = np.asarray(call_julia(self._jl.candidate, self._engine)) + masked = values.T[None, :, None, :] * self._problem.grids.active_mask + sums = monitor.split_sums(masked, dz) + self._split_removed += float(sums[0]) + self._split_found = sums[1:] self._alarm = float(call_julia(self._jl.commit_b, self._engine, dz, nogil=True)) if self._alarm > 1e-6 and not self._alarm_reported: self._alarm_reported = True @@ -844,6 +854,14 @@ def close(self) -> None: self._rows.clear() +def _splits(problem: KernelProblem) -> bool: + """Return whether accepted steps apply the split-step temporal collar.""" + response = problem.responses + return response.absorber_scheme == "split_step" and ( + response.temporal_absorber is not None + ) + + def _responses_recycle(problem: KernelProblem) -> bool: """Decide whether accepted-step absorption preserves the last source. From 63e02bf2c84be1561e224b910ba2c83addc0b38b Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 13:43:09 +0000 Subject: [PATCH 003/107] Julia: one source for CPU and GPU, any precision [skip ci] The engine is rewritten around a small device layer (launch.jl): every state-sized operation is a scalar body launched over (t, m) by each!, down columns by each_column!, or folded by reduce_each, on Arrays or a GPU array type, of Float32 or Float64. Inverse FFTs are unnormalised and their scale folded into the next coefficient; the DOPRI combination, candidate and controller norms are one pass; FSAL keeps stage one in place; FFTW plans follow native's policy (measure serial rows and planes). Co-Authored-By: Claude Opus 5.5 --- julia/profile.py | 55 +++ julia/src/SolpropJulia.jl | 477 +++------------------ julia/src/adams.jl | 361 +++++++++------- julia/src/dopri.jl | 170 ++++++++ julia/src/free.jl | 430 ++++++++++--------- julia/src/launch.jl | 134 ++++++ julia/src/modal.jl | 189 +++++++++ julia/src/responses.jl | 566 +++++++++++++------------ julia/src/rk4.jl | 84 ++-- julia/src/stages.jl | 87 ++-- src/solprop/backends/julia/_backend.py | 4 +- 11 files changed, 1421 insertions(+), 1136 deletions(-) create mode 100644 julia/profile.py create mode 100644 julia/src/dopri.jl create mode 100644 julia/src/launch.jl create mode 100644 julia/src/modal.jl diff --git a/julia/profile.py b/julia/profile.py new file mode 100644 index 000000000..7abf9421b --- /dev/null +++ b/julia/profile.py @@ -0,0 +1,55 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""Profile the Julia engine on one row of a benchmark plan. + +``python julia/profile.py PLAN.json ROW [FRACTION]`` builds the row's case for the +julia backend, warms it up, then samples Julia's stacks over a propagation to +``FRACTION`` of the row's stop (default 1) and prints the flat profile. Run it with +``SOLPROP_JULIA_THREADS=1``: Julia's sampling profiler is unreliable when Python +owns the threads. +""" + +import json +import sys +import time + +from benchmarks.builders import build +from solprop.backends import select + + +def main() -> None: + """Profile one plan row.""" + plan = json.loads(open(sys.argv[1], encoding="utf-8").read()) # noqa: PTH123, SIM115 + row = next(r for r in plan["rows"] if sys.argv[2] in r["id"]) + configuration = row["configuration"] | {"backend": "julia"} + fraction = float(sys.argv[3]) if len(sys.argv) > 3 else 1.0 # noqa: PLR2004 + simulation = build(configuration) + problem = simulation.translate() + engine = select( + "julia", + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + stop = fraction * float(configuration["stop"]) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(0.5 * stop) + from juliacall import Main as jl # noqa: PLC0415 - after the runtime starts + jl.seval("using Profile; Profile.init(n=10^7, delay=0.0005)") + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + jl.seval("Profile.clear(); Profile.start_timer()") + started = time.perf_counter() + engine.propagate_to(stop) + seconds = time.perf_counter() - started + jl.seval("Profile.stop_timer()") + jl.seval( + "Profile.print(IOContext(stdout, :displaysize => (200, 220)); format=:flat, " + "sortedby=:count, mincount=20, noisefloor=1)" + ) + sys.stdout.write(f"\n{row['id']}: {seconds:.3f} s to {stop:.3g} m\n") + + +if __name__ == "__main__": + main() diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 8194709b0..f169bca67 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -1,12 +1,22 @@ # SPDX-FileCopyrightText: 2026 John C. Travers and contributors # SPDX-License-Identifier: GPL-3.0-or-later -"""The Julia backend experiment's engine. All arrays behind the bridge are owned.""" +"""The Julia backend experiment's engine. + +One source for every device and precision: the arrays are `Array`s or a GPU array type +(loaded by a package extension), of `Float64` or `Float32`, and every state-sized +operation is a scalar body launched by `each!`, `each_column!` or `reduce_each` +(`launch.jl`). FFTs go through AbstractFFTs plans and contractions through `mul!`, so +FFTW and BLAS on a CPU, cuFFT and cuBLAS on an NVIDIA GPU. A body must capture only +arrays and scalars, never a configuration or workspace: those hold plans and strings, +which a GPU kernel cannot take. +""" module SolpropJulia using LinearAlgebra using FFTW using PythonCall import AcceleratedKernels as AK +import KernelAbstractions as KA # The digest of the sources this module was loaded from, set by the Python loader. const SOURCE_DIGEST = Ref("") @@ -22,451 +32,88 @@ mutable struct Engine{C,W} factor::Float64 end -# These loops inline their body for one task, and use the same body on GPU arrays. -function foreach_element(f, a, tasks) - AK.foreachindex(f, a; max_tasks=tasks, min_elems=4096) -end - -# Host traversal removes the per-sample integer divide. Device arrays retain a -# flat index kernel with the same scalar body; threading needs enough work per task. -function foreach_sample(f, a, tasks) - nr = size(a,1) - foreach_element(a,tasks) do i - f(mod1(i,nr),(i-1)÷nr+1,i) - end -end -function foreach_sample(f, a::StridedMatrix, tasks) - nr = size(a,1) - AK.foreachindex(axes(a,2);max_tasks=tasks,min_elems=max(1,cld(32768,nr))) do m - @inbounds @simd for row in axes(a,1) - @inline f(row,m,row+(m-1)*nr) - end - end -end - -@inline polarization(value::Real, factor, analytic_factor) = factor*(value*value)*value -@inline polarization(value::Complex, factor, analytic_factor) = factor*analytic_factor*abs2(value)*real(value) - -function polarize!(nodes, values, c, factor=c.factor) - nt = size(nodes,1) - foreach_element(nodes,c.tasks) do i - @inbounds nodes[i] = polarization(values[i],factor,c.analytic_factor)*c.window[mod1(i,nt)] - end -end - -# The first profile was dominated by indexing the pointwise Kerr product. This -# CPU-only traversal removes integer division and exposes independent time samples -# to SIMD. The scalar arithmetic is the same as the generic device-ready body. -const HostRealMatrix = Union{Matrix{Float64},SubArray{Float64,2,Matrix{Float64}}} -function polarize_column!(nodes, values, window, factor, analytic_factor, node) - @inbounds @simd for t in axes(nodes,1) - nodes[t,node] = polarization(values[t,node],factor,analytic_factor)*window[t] - end - nothing -end - -function polarize!(nodes::HostRealMatrix, values, c, factor=c.factor) - AK.foreachindex(axes(nodes,2); max_tasks=c.tasks,min_elems=max(1,cld(32768,size(nodes,1)))) do node - polarize_column!(nodes,values,c.window,factor,c.analytic_factor,node) - end -end - -function polarize_envelope!(nodes, values, c, factor) - foreach_sample(nodes,c.tasks) do t,m,i - @inbounds nodes[i] = factor*c.analytic_factor*abs2(values[i])*values[i]*c.window[t] - end -end - -# AbstractFFTs' normalized inverse plan performs a serial lmul! after its FFT. -# Keep exactly that scale and multiplication order, distributing only independent -# samples when the measured operation is large enough to justify task launches. -fft_apply!(destination,plan,source,c)=mul!(destination,plan,source) -function fft_apply!(destination,plan::FFTW.ScaledPlan,source,c) - if !c.parallel_fft_scale || c.tasks == 1 || length(destination) < 32768 - return mul!(destination,plan,source) - end - mul!(destination,plan.p,source) - scale=plan.scale - AK.foreachindex(1:cld(length(destination),32768);max_tasks=c.tasks,min_elems=1) do block - first=32768(block-1)+1 - last=min(first+32767,length(destination)) - @inbounds @simd for i in first:last - destination[i]=scale*destination[i] - end - end - destination -end +include("launch.jl") +include("responses.jl") +include("modal.jl") +include("free.jl") +include("dopri.jl") +include("rk4.jl") +include("adams.jl") +include("stages.jl") -# AppleAccelerate extends AbstractFFTs for dense Arrays. A strided view selects -# FFTW's planner explicitly, keeping this BLAS choice separate from FFT choice. -fft_storage(a) = view(a, :, :) +real_type(engine) = real(eltype(engine.work.y)) +"""Read the shared settings and route to the modal or the free-space engine.""" function create(input) - matrix(name, T) = Matrix{T}(input[name]) - vector(name, T) = Vector{T}(input[name]) - scalar(name, T) = convert(T, input[name]) - tasks = scalar("threads", Int) - FFTW.set_num_threads(scalar("fft_threads", Int)) - BLAS.set_num_threads(scalar("blas_threads", Int)) - plan_flag = lowercase(get(ENV,"SOLPROP_FFTW_PLAN","estimate")) - fft_flags = get(Dict("estimate"=>FFTW.ESTIMATE,"measure"=>FFTW.MEASURE,"patient"=>FFTW.PATIENT),plan_flag,nothing) - isnothing(fft_flags) && throw(ArgumentError("SOLPROP_FFTW_PLAN must be estimate, measure or patient")) - config = ( - plan_flag=plan_flag, fft_flags=fft_flags, - parallel_fft_scale=get(ENV,"SOLPROP_JULIA_PARALLEL_FFT_SCALE","1")=="1", - real_root=get(ENV,"SOLPROP_JULIA_REAL_ROOT","1")=="1", - skip_zero_plasma=get(ENV,"SOLPROP_JULIA_SKIP_ZERO_PLASMA","1")=="1", - fft_threads=scalar("fft_threads",Int), - blas_threads=scalar("blas_threads",Int), - raman_fft_threads=haskey(input,"raman_fft_threads") ? scalar("raman_fft_threads",Int) : scalar("fft_threads",Int), - transverse_fft_threads=haskey(input,"transverse_fft_threads") ? scalar("transverse_fft_threads",Int) : scalar("fft_threads",Int), - envelope=haskey(input,"envelope") && scalar("envelope",Bool), - low_storage=haskey(input,"low_storage") && scalar("low_storage",Bool), - free=haskey(input,"free") && scalar("free",Bool), - linear=matrix("linear", ComplexF64), prefactor=matrix("prefactor", ComplexF64), - synthesis=matrix("synthesis", Float64), projection=matrix("projection", Float64), - projection_coarse=matrix("projection_coarse", Float64), embedded=scalar("embedded", Bool), - spatial_absorber=haskey(input,"spatial_absorber") ? matrix("spatial_absorber",Float64) : zeros(0,0), - crop=vector("crop", Int) .+ 1, mask=vector("mask", Bool), - norm_mask=vector("norm_mask", Bool), weights=vector("weights", Float64), - window=vector("window", Float64), omega_window=vector("omega_window", Float64), - rate=vector("rate", Float64), coarse_rate=vector("coarse_rate", Float64), - a=matrix("a", Float64), b=vector("b", Float64), e=vector("e", Float64), - c=vector("c", Float64), factor=scalar("factor", Float64), - analytic=scalar("analytic", Bool), analytic_factor=scalar("analytic_factor", Float64), - split=scalar("split", Bool), rtol=scalar("rtol", Float64), atol=scalar("atol", Float64), - tasks=tasks, cache_propagators=haskey(input,"cache_propagators") ? scalar("cache_propagators",Bool) : true, - ) - config.free && return create_free(config, input) - # The translated rates are constant over a trial. An exactly absent loss - # needs no additive temporal FFT; the accepted-step split remains separate. - active_absorber = any(!iszero,config.spatial_absorber) || - (!config.split && any(!iszero,config.rate)) - config = merge(config, (modal_in_stage_absorber=( - get(ENV,"SOLPROP_JULIA_SKIP_ZERO_MODAL_ABSORBER","1") == "1" ? - active_absorber : (!config.split || !isempty(config.spatial_absorber)) - ),)) - nw, nm = size(config.linear) - nt = length(config.window) - chunk = min(scalar("chunk", Int), size(config.synthesis, 2)) - nf = config.envelope ? nt : nt ÷ 2 + 1 - T = config.envelope ? ComplexF64 : Float64 - fine = zeros(ComplexF64, nf, nm) - modal = zeros(T, nt, nm) - nodes = zeros(T, nt, chunk) - analytic = zeros(ComplexF64, nt, chunk) - coarse = zeros(T, length(config.coarse_rate), nm) - work = ( - adams=adams_workspace(input,nw,nm), - path=path_workspace(input,config), - raman=raman_workspace(input,config,nt,chunk), - plasma=plasma_workspace(input,config,nt,chunk,nm,size(config.synthesis,2)), - y=zeros(ComplexF64, nw, nm), candidate=zeros(ComplexF64, nw, nm), - lab=zeros(ComplexF64, nw, nm), source=zeros(ComplexF64, nw, nm), - fsal=zeros(ComplexF64, nw, nm), error=zeros(ComplexF64, nw, nm), - stages=zeros(ComplexF64, nw, nm, length(config.c)), - forward=zeros(ComplexF64, nw, nm, length(config.c)), inverse=zeros(ComplexF64, nw, nm, length(config.c)), - fine=fine, modal=modal, nodes=nodes, analytic=analytic, - projected=zeros(T,nt, nm), projected_coarse=zeros(T,nt,nm), coarse_spec=similar(fine), absorber=zeros(T,nt, nm), absorber_spec=similar(fine), - coarse=coarse, partials=zeros(3, nm), - inverse_plan=config.envelope ? plan_ifft(fft_storage(fine),1;flags=config.fft_flags) : plan_irfft(fft_storage(fine), nt, 1; flags=config.fft_flags), - forward_plan=config.envelope ? plan_fft(fft_storage(modal),1;flags=config.fft_flags) : plan_rfft(fft_storage(modal), 1; flags=config.fft_flags), - analytic_forward=plan_fft!(fft_storage(analytic), 1; flags=config.fft_flags), - analytic_inverse=plan_ifft!(fft_storage(analytic), 1; flags=config.fft_flags), - coarse_inverse=config.envelope ? plan_ifft(fft_storage(zeros(ComplexF64,nw,nm)),1;flags=config.fft_flags) : plan_irfft(fft_storage(zeros(ComplexF64,nw,nm)), length(config.coarse_rate), 1; flags=config.fft_flags), - coarse_forward=config.envelope ? plan_fft(fft_storage(coarse),1;flags=config.fft_flags) : plan_rfft(fft_storage(coarse), 1; flags=config.fft_flags), + host = HostInput(input) + T = host.has("precision") && host.string("precision") == "single" ? Float32 : Float64 + backend = device_backend(Val(Symbol(host.has("device") ? host.string("device") : "cpu"))) + FFTW.set_num_threads(host.int("fft_threads")) + BLAS.set_num_threads(host.int("blas_threads")) + c = ( + backend=backend, T=T, tasks=host.int("threads"), + fft_threads=host.int("fft_threads"), + raman_fft_threads=host.has("raman_fft_threads") ? host.int("raman_fft_threads") : host.int("fft_threads"), + transverse_fft_threads=host.has("transverse_fft_threads") ? host.int("transverse_fft_threads") : host.int("fft_threads"), + envelope=host.flag("envelope"), low_storage=host.flag("low_storage"), + free=host.flag("free"), split=host.flag("split"), analytic=host.flag("analytic"), + analytic_factor=T(host.real("analytic_factor")), factor=host.real("factor"), + rtol=host.real("rtol"), atol=host.real("atol"), + cache_propagators=host.has("cache_propagators") ? host.flag("cache_propagators") : true, ) - Engine(config, work, false, 0, NaN,config.factor) + c.free ? create_free(c, host) : create_modal(c, host) end -function load!(engine, input) - copyto!(engine.work.y, Matrix{ComplexF64}(input)) +load!(engine, input) = (copyto!(engine.work.y, device_matrix(engine, input)); reset!(engine)) +function reset!(engine) mask!(engine, engine.work.y) engine.fsal_valid = false engine.calls = 0 nothing end +device_matrix(engine, input) = + upload(engine.config.backend, Matrix{Complex{real_type(engine)}}(input)) function mask!(engine, values) mask = engine.config.mask - foreach_sample(values, engine.config.tasks) do f,m,i - @inbounds begin - if !mask[f] - values[i] = 0 - end - end - end -end - -"""Evaluate the translated source, with padding/crop scales already in the seam.""" -function source!(engine, lab; quadrature=false) - c, w = engine.config, engine.work - c.free && return source_free!(engine,lab) - nt, nm = size(w.modal) - nw = size(lab, 1) - fill!(w.fine, 0) - foreach_sample(lab, c.tasks) do f,m,i - @inbounds begin - w.fine[c.crop[f],m] = lab[i] - end - end - fft_apply!(w.modal,w.inverse_plan,w.fine,c) - fill!(w.projected, 0) - quadrature && fill!(w.projected_coarse, 0) - clear_plasma!(w.plasma) - if engine.factor != 0 || !isnothing(w.plasma) || !isnothing(w.raman) - chunk = size(w.nodes,2) - for first in 1:chunk:size(c.synthesis,2) - last = min(first+chunk-1, size(c.synthesis,2)) - count = last-first+1 - nodes = @view w.nodes[:,1:count] - mul!(nodes, w.modal, @view(c.synthesis[:,first:last])) - if !isnothing(w.plasma) - plasma_current!(w.plasma,nodes,c,first) - project_plasma!(w.plasma,c,first,last,quadrature) - end - if c.envelope - isnothing(w.raman) || raman_response!(w.raman,nodes,nodes,c) - polarize_envelope!(nodes,nodes,c,engine.factor) - elseif c.analytic || (!isnothing(w.raman) && !w.raman.thg) - fill!(w.analytic, 0) - @views w.analytic[:,1:count] .= nodes - w.analytic_forward * w.analytic - foreach_sample(w.analytic, c.tasks) do f,m,i - @inbounds begin - w.analytic[i] *= (f == 1 || f == nt÷2+1) ? 1 : f <= nt÷2 ? 2 : 0 - end - end - fft_apply!(w.analytic,w.analytic_inverse,w.analytic,c) - isnothing(w.raman) || raman_response!(w.raman,nodes,w.analytic,c) - polarize!(nodes,c.analytic ? w.analytic : nodes,c,engine.factor) - else - isnothing(w.raman) || raman_response!(w.raman,nodes,w.analytic,c) - polarize!(nodes,nodes,c,engine.factor) - end - isnothing(w.raman) || add_raman!(w.raman,nodes,c) - mul!(w.projected, nodes, @view(c.projection[first:last,:]), 1.0, 1.0) - if quadrature && c.embedded - mul!(w.projected_coarse, nodes, @view(c.projection_coarse[first:last,:]), 1.0, 1.0) - end - end - end - mul!(w.fine, w.forward_plan, w.projected) - isnothing(w.plasma) || add_plasma!(w.fine,w.plasma,w.forward_plan,c) - in_stage_absorber = c.modal_in_stage_absorber - if in_stage_absorber - if c.split - fill!(w.absorber, 0) - else - foreach_sample(w.absorber, c.tasks) do t,m,i - @inbounds begin - w.absorber[i] = -0.5 * c.rate[t] * w.modal[i] - end - end - end - # The shared radial map has no temporal pad scale. Its loss is additive, - # independent of Kerr and its material prefactor, under either time scheme. - if !isempty(c.spatial_absorber) - mul!(w.absorber, w.modal, c.spatial_absorber, 1.0, 1.0) - end - mul!(w.absorber_spec, w.forward_plan, w.absorber) - end - foreach_sample(w.source, c.tasks) do f,m,i - @inbounds begin - value = c.prefactor[i] * c.omega_window[f] * w.fine[c.crop[f],m] - if in_stage_absorber && c.mask[f] - value += w.absorber_spec[c.crop[f],m] - end - w.source[i] = value - end - end - engine.calls += 1 - nothing -end - -# Constant linear tables make the propagators depend only on dz. Reuse is exact -# for equal step lengths; adaptive trials rebuild on every changed dz. -function propagators!(engine, dz) - engine.config.free && return - if !isnothing(engine.work.path) - path_propagators!(engine) - return - end - engine.config.cache_propagators && engine.propagator_dz == dz && return - c, w = engine.config, engine.work - n = length(w.y) - foreach_element(w.y,c.tasks) do i - @inbounds for stage in eachindex(c.c) - j = i + (stage-1)*n - exponent = (dz*c.c[stage])*c.linear[i] - w.forward[j] = exp(exponent) - w.inverse[j] = exp(-exponent) + each!(engine.config, size(values)...) do f, m + @inbounds if !mask[f] + values[f, m] = 0 end end - engine.propagator_dz = dz - nothing end -"""Form one IP-DOPRI5 candidate, preserving y even when the controller rejects it.""" -function trial!(engine, dz::Float64) - c, w = engine.config, engine.work - nw, nm = size(w.y) - ns = length(c.c) - propagators!(engine,dz) - for stage in 1:ns - !c.free && !isnothing(w.path) && material_stage!(engine,stage) - if c.free && stage == 1 && engine.fsal_valid - # At c[1] == 0 the interaction-frame derivative is the FSAL source. - copyto!(@view(w.stages[:,:,1]),w.fsal) - continue - end - c.free && free_propagators!(engine,dz*c.c[stage]) - slot = c.free ? 1 : stage - foreach_sample(w.y, c.tasks) do f,m,i - @inbounds begin - combination = zero(ComplexF64) - for previous in 1:stage-1 - combination += c.a[stage,previous] * w.stages[i+(previous-1)*length(w.y)] - end - w.lab[i] = w.forward[i+(slot-1)*length(w.y)] * (w.y[i] + dz*combination) - end - end - if stage == 1 && engine.fsal_valid - copyto!(w.source, w.fsal) - else - source!(engine, w.lab; quadrature=stage==ns) - if stage == 1 - copyto!(w.fsal, w.source) - engine.fsal_valid = true - end - end - foreach_sample(w.source, c.tasks) do f,m,i - @inbounds begin - w.stages[i+(stage-1)*length(w.y)] = w.inverse[i+(slot-1)*length(w.y)] * w.source[i] - end - end - end - foreach_sample(w.y, c.tasks) do f,m,i - @inbounds begin - solution, defect = zero(ComplexF64), zero(ComplexF64) - for stage in 1:ns - value = w.stages[i+(stage-1)*length(w.y)] - solution += c.b[stage]*value - defect += c.e[stage]*value - end - flow = w.forward[i+(c.free ? 0 : ns-1)*length(w.y)] - w.candidate[i] = flow*(w.y[i]+dz*solution) - w.error[i] = flow*(dz*defect) - end - end - # Column partials retain a clear summation bound and require no per-trial arrays. - AK.foreachindex(1:nm; max_tasks=c.tasks, min_elems=max(1,cld(32768,nw))) do m - @inbounds begin - before, after = 0.0, 0.0 - for f in 1:nw - if c.norm_mask[f] - before += abs2(w.y[f,m]) - after += abs2(w.candidate[f,m]) - end - end - w.partials[1,m], w.partials[2,m] = before, after - end - end - magnitude = max(sqrt(sum(@view w.partials[1,:])), sqrt(sum(@view w.partials[2,:]))) - AK.foreachindex(1:nm; max_tasks=c.tasks, min_elems=max(1,cld(32768,nw))) do m - @inbounds begin - residual = 0.0 - for f in 1:nw - if c.norm_mask[f] - scale = c.rtol*c.weights[f]*magnitude+c.atol - value = w.error[f,m] - residual += scale == 0 && value == 0 ? 0.0 : abs2(value/scale) - end - end - w.partials[3,m] = residual - end - end - sqrt(sum(@view w.partials[3,:])) -end - -function commit!(engine, dz::Float64) - c, w = engine.config, engine.work - mask!(engine, w.candidate) - if c.split && any(!iszero, c.coarse_rate) - if c.free - split_free!(engine,dz) - else - fft_apply!(w.coarse,w.coarse_inverse,w.candidate,c) - nt = size(w.coarse,1) - foreach_sample(w.coarse, c.tasks) do t,m,i - @inbounds begin - w.coarse[i] *= exp(-0.5*dz*c.coarse_rate[t]) - end - end - mul!(w.candidate, w.coarse_forward, w.coarse) - end - mask!(engine, w.candidate) - engine.fsal_valid = false - else - if !c.low_storage - copyto!(w.fsal, w.source) - engine.fsal_valid = true - end - end - copyto!(w.y, w.candidate) - if !c.embedded - return NaN - end - mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) - isnothing(w.plasma) || add_plasma!(w.coarse_spec,w.plasma,w.forward_plan,c;coarse=true) - scale, defect = 0.0, 0.0 - for m in axes(w.y,2), f in axes(w.y,1) - weight = c.prefactor[f,m]*c.omega_window[f] - fine = weight*w.fine[c.crop[f],m] - coarse = weight*w.coarse_spec[c.crop[f],m] - scale += abs2(fine) - defect += abs2(coarse-fine) - end - scale == 0 ? NaN : sqrt(defect/scale) -end - -snapshot(engine) = copy(engine.work.y) -candidate(engine) = copy(engine.work.candidate) -source_snapshot(engine) = copy(engine.work.source) -error_snapshot(engine) = copy(engine.work.error) +snapshot(engine) = complex_host(engine.work.y) +candidate(engine) = complex_host(engine.work.candidate) +complex_host(a) = Matrix{ComplexF64}(Array(a)) function evaluate!(engine, input) - lab = Matrix{ComplexF64}(input) - source!(engine, lab) - source_snapshot(engine) + copyto!(engine.work.lab, device_matrix(engine, input)) + source!(engine, engine.work.lab) + complex_host(engine.work.source) end -# Plans have implementation-owned storage; explicitly owned arrays are counted here. +# Plans hold implementation-owned storage; the arrays the engine owns are counted. function ledger(engine) result = Dict{String,Int}() - function visit(prefix,object) + function visit(prefix, object) for name in propertynames(object) - value=getproperty(object,name) - key="$(prefix).$(name)" - if value isa Array && !isempty(value) - result[key]=sizeof(value) + value = getproperty(object, name) + key = "$(prefix).$(name)" + if value isa DenseArray && !isempty(value) + result[key] = sizeof(value) elseif value isa NamedTuple - visit(key,value) + visit(key, value) end end end - visit("config",engine.config) - visit("work",engine.work) + visit("config", engine.config) + visit("work", engine.work) result end -include("adams.jl") -include("rk4.jl") -include("stages.jl") -include("responses.jl") -include("free.jl") - -device_name(engine) = "cpu" -runtime() = (string(VERSION), Threads.nthreads(), FFTW.get_num_threads(), BLAS.get_num_threads(), string(BLAS.get_config())) +device_name(engine) = device_label(engine.config.backend) +runtime() = (string(VERSION), Threads.nthreads(), FFTW.get_num_threads(), + BLAS.get_num_threads(), string(BLAS.get_config())) const rk4_b = rk4! const configure_stages_b = configure_stages! const load_b = load! diff --git a/julia/src/adams.jl b/julia/src/adams.jl index 423411971..d174b88d6 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -1,229 +1,262 @@ # SPDX-FileCopyrightText: 2026 John C. Travers and contributors # SPDX-License-Identifier: GPL-3.0-or-later -# SEP 16's resident exponential PEC. The Python march supplies scalar polynomial -# tables and chooses steps/orders; state-sized arithmetic and history stay here. -const RECIP_FACTORIAL = ntuple(k -> 1.0/factorial(k-1), 10) -function phi_values(x,::Val{N}) where N - if abs(x)>3.0 - out=ntuple(_->zero(ComplexF64),N+1) - out=Base.setindex(out,exp(x),1) +# SEP 16's resident exponential predictor-corrector. The Python march chooses steps +# and orders and supplies the scalar coefficient tables; the history and every +# state-sized operation stay here. + +const RECIP_FACTORIAL = ntuple(k -> 1.0 / factorial(k - 1), 10) + +"""`phi_0(x) .. phi_N(x)` by a shifted series and scaling and squaring. + +Evaluated in binary64 at either precision: the flow and its moments are rounded once +to the state's precision (SEP 33). +""" +@inline function phi_values(x::ComplexF64, ::Val{N}) where {N} + if abs(x) > 3.0 + out = ntuple(_ -> zero(ComplexF64), Val(N + 1)) + out = Base.setindex(out, exp(x), 1) for k in 1:N - out=Base.setindex(out,(out[k]-RECIP_FACTORIAL[k])/x,k+1) + out = Base.setindex(out, (out[k] - RECIP_FACTORIAL[k]) / x, k + 1) end return out end - levels=abs(x)<=0.5 ? 0 : ceil(Int,log2(abs(x)/0.5)) - y=x/2.0^levels - term=complex(RECIP_FACTORIAL[N+1]) - total=term + levels = abs(x) <= 0.5 ? 0 : ceil(Int, log2(abs(x) / 0.5)) + y = x / 2.0^levels + term = complex(RECIP_FACTORIAL[N+1]) + total = term for m in 1:23 - term=term*y/(m+N) - total+=term + term = term * y / (m + N) + total += term end - out=ntuple(_->zero(ComplexF64),N+1) - out=Base.setindex(out,total,N+1) + out = ntuple(_ -> zero(ComplexF64), Val(N + 1)) + out = Base.setindex(out, total, N + 1) for k in N-1:-1:1 - out=Base.setindex(out,RECIP_FACTORIAL[k+1]+y*out[k+2],k+1) + out = Base.setindex(out, RECIP_FACTORIAL[k+1] + y * out[k+2], k + 1) end - out=Base.setindex(out,exp(y),1) + out = Base.setindex(out, exp(y), 1) for _ in 1:levels - old=out - out=Base.setindex(out,old[1]*old[1],1) + old = out + out = Base.setindex(out, old[1] * old[1], 1) for k in 1:N - value=old[1]*old[k+1] + value = old[1] * old[k+1] for j in 1:k - value+=old[j+1]*RECIP_FACTORIAL[k-j+1] + value += old[j+1] * RECIP_FACTORIAL[k-j+1] end - out=Base.setindex(out,value/2.0^k,k+1) + out = Base.setindex(out, value / 2.0^k, k + 1) end end out end -phi_snapshot(x,order)=collect(phi_values(ComplexF64(x),Val(Int(order)))) +phi_snapshot(x, order) = collect(phi_values(ComplexF64(x), Val(Int(order)))) -function adams_workspace(input,nw,nm) - order=haskey(input,"adams_order") ? Int(input["adams_order"]) : 0 - order==0 && return nothing - slots=order+2 - width=order+1 - compensated=Bool(input["adams_compensated"]) - nphi=haskey(input,"phi_terms") ? size(Array{ComplexF64,3}(input["phi_terms"]),3) : 1 - (store=zeros(ComplexF64,nw,nm,slots), - states=zeros(ComplexF64,nw,nm,compensated ? slots : 0), - rates=zeros(ComplexF64,nw,nm,compensated ? slots : 0), - moments=zeros(ComplexF64,nw,nm,width), - carried=zeros(ComplexF64,nw,nm,compensated ? width-1 : 0), - endpoint=zeros(ComplexF64,compensated ? nw : 0,compensated ? nm : 0), - predictor=zeros(width,width),corrector=zeros(width,width),defects=zeros(3,2width), - spans=zeros(width),cpredictor=zeros(width),ccorrector=zeros(width),cdefects=zeros(3,width), - rate_weights=zeros(nphi),slots=zeros(Int,slots),sizes=zeros(Int,3), - norms=zeros(3,nm),compensated=compensated) +function adams_workspace(c, host, nw, nm) + order = host.has("adams_order") ? host.int("adams_order") : 0 + order == 0 && return nothing + C = Complex{c.T} + slots, width = order + 2, order + 1 + compensated = host.flag("adams_compensated") + held(dims...) = compensated ? dzeros(c, C, dims...) : dzeros(c, C, ntuple(_ -> 0, length(dims))...) + nphi = host.has("phi_terms") ? size(host.array("phi_terms", ComplexF64), 3) : 1 + # The trial's coefficient tables, filled on the host and copied over once a trial. + tables = (predictor=zeros(width, width), corrector=zeros(width, width), + defects=zeros(3, 2width), spans=zeros(width), cpredictor=zeros(width), + ccorrector=zeros(width + 1), cdefects=zeros(3, width), rate=zeros(nphi), + slots=zeros(Int, slots)) + (store=dzeros(c, C, nw, nm, slots), states=held(nw, nm, slots), rates=held(nw, nm, slots), + moments=dzeros(c, C, nw, nm, width), carried=held(nw, nm, max(width - 1, 0)), + endpoint=held(nw, nm), host=tables, device=map(a -> upload(c.backend, copy(a)), tables), + sizes=zeros(Int, 3), compensated=compensated) end -function configure_adams!(engine,predictor,corrector,defects,slots,spans,cpredictor,ccorrector,cdefects,rate) - a=engine.work.adams - p,q,d=Matrix{Float64}(predictor),Matrix{Float64}(corrector),Matrix{Float64}(defects) - order,width,count=size(p,1),size(q,1),size(d,1) - a.sizes .= (order,width,count) - a.predictor[1:order,1:order] .= p - a.corrector[1:width,1:width] .= q - a.defects[1:count,1:2width] .= d - incoming=Vector{Int}(slots) - a.slots[1:length(incoming)] .= incoming .+ 1 + +function configure_adams!(engine, predictor, corrector, defects, slots, spans, cpredictor, + ccorrector, cdefects, rate) + a = engine.work.adams + h = a.host + p, q, d = Matrix{Float64}(predictor), Matrix{Float64}(corrector), Matrix{Float64}(defects) + order, width, count = size(p, 1), size(q, 1), size(d, 1) + a.sizes .= (order, width, count) + h.predictor[1:order, 1:order] .= p + h.corrector[1:width, 1:width] .= q + h.defects[1:count, 1:2width] .= d + incoming = Vector{Int}(slots) + h.slots[1:length(incoming)] .= incoming .+ 1 if a.compensated - s,cp,cc=Vector{Float64}(spans),Vector{Float64}(cpredictor),Vector{Float64}(ccorrector) - a.spans[1:length(s)] .= s - a.cpredictor[1:length(cp)] .= cp - a.ccorrector[1:length(cc)] .= cc - a.cdefects[1:count,1:width] .= Matrix{Float64}(cdefects) - a.rate_weights .= Vector{Float64}(rate) + s, cp, cc = Vector{Float64}(spans), Vector{Float64}(cpredictor), Vector{Float64}(ccorrector) + h.spans[1:length(s)] .= s + h.cpredictor[1:length(cp)] .= cp + h.ccorrector[1:length(cc)] .= cc + h.cdefects[1:count, 1:width] .= Matrix{Float64}(cdefects) + h.rate .= Vector{Float64}(rate) end + foreach(copyto!, a.device, a.host) nothing end -function configure_adams_rate!(engine,rate) - engine.work.adams.rate_weights .= Vector{Float64}(rate) +function configure_adams_rate!(engine, rate) + a = engine.work.adams + a.host.rate .= Vector{Float64}(rate) + copyto!(a.device.rate, a.host.rate) nothing end -@inline function adams_rate(engine,f,m) - p,a=engine.work.path,engine.work.adams - isnothing(p) && return engine.config.linear[f,m] - value=0.0im - @inbounds for term in axes(p.phi,3) - value+=p.phi[f,m,term]*a.rate_weights[term] + +"""`D(z)` at one element: the constant operator, or its expansion's weighted terms.""" +@inline function adams_rate(linear, phi, weights, f, m) + phi === nothing && return @inbounds linear[f, m] + value = zero(eltype(phi)) + @inbounds for term in axes(phi, 3) + value += phi[f, m, term] * weights[term] end value end + +path_terms(w) = w.path === nothing ? nothing : w.path.phi + function adams_start!(engine) - w=engine.work - isnothing(w.path) || material_stage!(engine,1) - source!(engine,w.y) - copyto!(@view(w.adams.store[:,:,1]),w.source) - if w.adams.compensated - copyto!(@view(w.adams.states[:,:,1]),w.y) - foreach_sample(w.y,engine.config.tasks) do f,m,i - @inbounds w.adams.rates[f,m,1]=adams_rate(engine,f,m) + c, w = engine.config, engine.work + a = w.adams + w.path === nothing || material_stage!(engine, 1) + source!(engine, w.y) + copyto!(@view(a.store[:, :, 1]), w.source) + if a.compensated + copyto!(@view(a.states[:, :, 1]), w.y) + (; rates) = a + linear, phi, weights = c.linear, path_terms(w), a.device.rate + each!(c, size(w.y)...) do f, m + @inbounds rates[f, m, 1] = adams_rate(linear, phi, weights, f, m) end end nothing end -function adams_trial!(engine,h) - adams_trial_width!(engine,h,Val(engine.work.adams.sizes[2])) -end -function adams_trial_width!(engine,h,::Val{N}) where N - c,w=engine.config,engine.work - a=w.adams - order,_,count=a.sizes - foreach_sample(w.y,c.tasks) do f,m,i + +adams_trial!(engine, h) = adams_trial_width!(engine, h, Val(engine.work.adams.sizes[2])) + +function adams_trial_width!(engine, h, ::Val{N}) where {N} + c, w = engine.config, engine.work + a = w.adams + order, _, count = a.sizes + T = real_type(engine) + C = Complex{T} + (; y, lab, error, forward, candidate, source) = w + (; store, states, rates, moments, carried, endpoint) = a + (; predictor, corrector, defects, spans, cpredictor, ccorrector, cdefects, slots) = a.device + linear, phi, weights, compensated = c.linear, path_terms(w), a.device.rate, a.compensated + delta = w.path === nothing ? nothing : w.path.delta_device + step = Float64(h) + mask = c.norm_mask + # The predictor, the flow and its moments, and the state's norm for the scale. + squared = reduce_each(+, zero(T), c, size(y)...) do f, m @inbounds begin - x=h*c.linear[i] - if !isnothing(w.path) - x=0.0im - for term in axes(w.path.phi,3) - x+=w.path.phi[f,m,term]*w.path.delta[term,end] + x = ComplexF64(step * linear[f, m]) + if phi !== nothing + x = zero(ComplexF64) + for term in axes(phi, 3) + x += phi[f, m, term] * delta[term, 7] end end - phi=phi_values(x,Val(N)) - w.forward[f,m,1]=phi[1] - value=0.0im + values = phi_values(x, Val(N)) + forward[f, m, 1] = values[1] + predicted = zero(C) for k in 1:N - moment=phi[k+1]/RECIP_FACTORIAL[k] - a.moments[f,m,k]=moment - if k<=order - weighted=0.0im + moment = C(values[k+1] / RECIP_FACTORIAL[k]) + moments[f, m, k] = moment + if k <= order + weighted = zero(C) for j in 1:order - weighted+=a.predictor[j,k]*a.store[f,m,a.slots[j]] + weighted += predictor[j, k] * store[f, m, slots[j]] end - value+=moment*weighted + predicted += moment * weighted end end - if a.compensated - correction=0.0im + if compensated + correction = zero(C) for j in 1:N-1 - slot=a.slots[j] - carried=exp(a.spans[j]*x)*(a.rates[f,m,slot]-x/h)*a.states[f,m,slot] - a.carried[f,m,j]=carried - j<=order && (correction+=a.cpredictor[j]*carried) + slot = slots[j] + value = C(exp(spans[j] * x)) * (rates[f, m, slot] - C(x / step)) * states[f, m, slot] + carried[f, m, j] = value + j <= order && (correction += cpredictor[j] * value) end - value+=correction - w.error[i]=adams_rate(engine,f,m) - end - predicted=phi[1]*w.y[i]+h*value - w.lab[i]=predicted - if a.compensated - a.endpoint[i]=(w.error[i]-x/h)*predicted + predicted += correction + error[f, m] = adams_rate(linear, phi, weights, f, m) end + value = C(values[1]) * y[f, m] + T(step) * predicted + lab[f, m] = value + compensated && (endpoint[f, m] = (error[f, m] - C(x / step)) * value) + mask[f] ? abs2(y[f, m]) : zero(T) end end - isnothing(w.path) || material_stage!(engine,length(c.c)) - source!(engine,w.lab;quadrature=true) - magnitude=sqrt(masked_squared(engine,w.y)) - AK.foreachindex(axes(w.y,2);max_tasks=c.tasks,min_elems=max(1,cld(32768,size(w.y,1)))) do m + w.path === nothing || material_stage!(engine, 7) + source!(engine, lab; quadrature=true) + magnitude = sqrt(squared) + relative, absolute, weight = T(c.rtol) * magnitude, T(c.atol), c.weights + zero3 = (zero(T), zero(T), zero(T)) + norms = reduce_each(.+, zero3, c, size(y)...) do f, m @inbounds begin - for row in 1:count - a.norms[row,m]=0.0 + corrected = zero(C) + for k in 1:N + weighted = corrector[1, k] * source[f, m] + for j in 2:N + weighted += corrector[j, k] * store[f, m, slots[j-1]] + end + corrected += moments[f, m, k] * weighted + end + if compensated + correction = ccorrector[1] * endpoint[f, m] + for j in 1:order + correction += ccorrector[j+1] * carried[f, m, j] + end + corrected += correction end - for f in axes(w.y,1) - corrected=0.0im - for k in 1:N - weighted=a.corrector[1,k]*w.source[f,m] + candidate[f, m] = forward[f, m, 1] * y[f, m] + T(step) * corrected + result = zero3 + if mask[f] + scale = relative * weight[f] + absolute + for row in 1:count + difference = defects[row, 1] * source[f, m] for j in 2:N - weighted+=a.corrector[j,k]*a.store[f,m,a.slots[j-1]] + difference += defects[row, j] * store[f, m, slots[j-1]] end - corrected+=a.moments[f,m,k]*weighted - end - if a.compensated - correction=a.ccorrector[1]*a.endpoint[f,m] - for j in 1:order - correction+=a.ccorrector[j+1]*a.carried[f,m,j] + polynomial = zero(C) + for k in 1:N + polynomial += defects[row, N+k] * moments[f, m, k] end - corrected+=correction - end - w.candidate[f,m]=w.forward[f,m,1]*w.y[f,m]+h*corrected - if c.norm_mask[f] - scale=c.rtol*c.weights[f]*magnitude+c.atol - for row in 1:count - difference=a.defects[row,1]*w.source[f,m] - polynomial=0.0im - for j in 2:N - difference+=a.defects[row,j]*a.store[f,m,a.slots[j-1]] - end - for k in 1:N - polynomial+=a.defects[row,N+k]*a.moments[f,m,k] - end - defect=difference*polynomial - if a.compensated - correction=a.cdefects[row,1]*a.endpoint[f,m] - for j in 1:N-1 - correction+=a.cdefects[row,j+1]*a.carried[f,m,j] - end - defect+=correction + defect = difference * polynomial + if compensated + correction = cdefects[row, 1] * endpoint[f, m] + for j in 1:N-1 + correction += cdefects[row, j+1] * carried[f, m, j] end - defect*=h - a.norms[row,m]+=scale==0 && defect==0 ? 0.0 : abs2(defect/scale) + defect += correction end + defect *= T(step) + score = scale == 0 && defect == 0 ? zero(T) : abs2(defect / scale) + result = Base.setindex(result, score, row) end end + result end end - [sqrt(sum(@view a.norms[row,:])) for row in 1:count] + [sqrt(Float64(norms[row])) for row in 1:count] end -function adams_accept!(engine,slot) - w=engine.work - copyto!(@view(w.adams.store[:,:,slot+1]),w.source) - if w.adams.compensated - copyto!(@view(w.adams.states[:,:,slot+1]),w.lab) - copyto!(@view(w.adams.rates[:,:,slot+1]),w.error) + +function adams_accept!(engine, slot) + w = engine.work + a = w.adams + copyto!(@view(a.store[:, :, slot+1]), w.source) + if a.compensated + copyto!(@view(a.states[:, :, slot+1]), w.lab) + copyto!(@view(a.rates[:, :, slot+1]), w.error) end nothing end -adams_rows(engine,name)=copy(getproperty(engine.work.adams,Symbol(name))) -function adams_load_rows!(engine,name,rows) - copyto!(getproperty(engine.work.adams,Symbol(name)),Array{ComplexF64,3}(rows)) +adams_rows(engine, name) = Array{ComplexF64}(Array(getproperty(engine.work.adams, Symbol(name)))) +function adams_load_rows!(engine, name, rows) + target = getproperty(engine.work.adams, Symbol(name)) + copyto!(target, upload(engine.config.backend, Array{eltype(target),3}(rows))) nothing end -const configure_adams_b=configure_adams! -const configure_adams_rate_b=configure_adams_rate! -const adams_start_b=adams_start! -const adams_trial_b=adams_trial! -const adams_accept_b=adams_accept! -const adams_load_rows_b=adams_load_rows! +const configure_adams_b = configure_adams! +const configure_adams_rate_b = configure_adams_rate! +const adams_start_b = adams_start! +const adams_trial_b = adams_trial! +const adams_accept_b = adams_accept! +const adams_load_rows_b = adams_load_rows! diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl new file mode 100644 index 000000000..2e0e38174 --- /dev/null +++ b/julia/src/dopri.jl @@ -0,0 +1,170 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The interaction-picture DOPRI5 trial and the accepted step's commit. + +"""Cache `exp(+-c_s dz L)` per stage: exact reuse while dz is unchanged.""" +function propagators!(engine, dz) + c, w = engine.config, engine.work + c.free && return nothing + if w.path !== nothing + path_propagators!(engine) + return nothing + end + c.cache_propagators && engine.propagator_dz == dz && return nothing + (; linear) = c + (; forward, inverse) = w + T = real_type(engine) + steps = ntuple(s -> T(dz * c.nodes_c[s]), Val(7)) + each!(c, size(linear)...) do f, m + @inbounds for s in 1:7 + exponent = steps[s] * linear[f, m] + forward[f, m, s] = exp(exponent) + inverse[f, m, s] = exp(-exponent) + end + end + engine.propagator_dz = dz + nothing +end + +"""Form one IP-DOPRI5 candidate and its error; the accepted state is untouched. + +Returns the scaled error norm. With a valid first-same-as-last sample the first stage +is the previous step's last source, which `commit!` left in stage one's slot. +""" +function trial!(engine, dz::Float64) + c, w = engine.config, engine.work + T = real_type(engine) + (; y, lab, stages, forward, inverse, source) = w + propagators!(engine, dz) + for stage in 1:7 + stage == 1 && engine.fsal_valid && continue + w.path !== nothing && material_stage!(engine, stage) + if stage == 1 + # c_1 = 0: both propagators are exactly the identity. + if !engine.fsal_valid + source!(engine, y) + copyto!(@view(stages[:, :, 1]), source) + end + continue + end + slot = c.free ? free_propagators!(engine, dz * c.nodes_c[stage]) : stage + row = ntuple(p -> T(dz * c.a[stage, p]), Val(6)) + each!(c, size(y)...) do f, m + @inbounds begin + combination = zero(eltype(y)) + for p in 1:stage-1 + combination += row[p] * stages[f, m, p] + end + lab[f, m] = forward[f, m, slot] * (y[f, m] + combination) + end + end + source!(engine, lab; quadrature=stage == 7) + each!(c, size(y)...) do f, m + @inbounds stages[f, m, stage] = inverse[f, m, slot] * source[f, m] + end + end + engine.fsal_valid = true + combine!(engine, dz, c.free ? 1 : 7) +end + +"""The candidate and the error estimate, and the controller's norm of the error. + +The norm is `‖e‖ / (rtol w max(‖y‖, ‖y_new‖) + atol)` over the in-band bins, as the +shared controller defines it; with uniform weights all three sums are one pass. +""" +function combine!(engine, dz, slot) + c, w = engine.config, engine.work + T = real_type(engine) + (; y, candidate, error, stages, forward) = w + mask = c.norm_mask + b = ntuple(s -> T(dz * c.b[s]), Val(7)) + e = ntuple(s -> T(dz * c.e[s]), Val(7)) + zero3 = (zero(T), zero(T), zero(T)) + sums = reduce_each(.+, zero3, c, size(y)...) do f, m + @inbounds begin + solution, defect = zero(eltype(y)), zero(eltype(y)) + for s in 1:7 + value = stages[f, m, s] + solution += b[s] * value + defect += e[s] * value + end + flow = forward[f, m, slot] + new = flow * (y[f, m] + solution) + estimate = flow * defect + candidate[f, m] = new + error[f, m] = estimate + mask[f] ? (abs2(y[f, m]), abs2(new), abs2(estimate)) : zero3 + end + end + magnitude = max(sqrt(sums[1]), sqrt(sums[2])) + if c.uniform + scale = T(c.rtol) * magnitude + T(c.atol) + return scale == 0 ? (sums[3] == 0 ? 0.0 : Inf) : Float64(sqrt(sums[3]) / scale) + end + weighted_norm(engine, error, magnitude) +end + +function weighted_norm(engine, error, magnitude) + c = engine.config + T = real_type(engine) + (; weights, norm_mask) = c + relative, absolute = T(c.rtol) * magnitude, T(c.atol) + residual = reduce_each(+, zero(T), c, size(error)...) do f, m + @inbounds begin + scale = relative * weights[f] + absolute + value = error[f, m] + norm_mask[f] && !(scale == 0 && value == 0) ? abs2(value / scale) : zero(T) + end + end + Float64(sqrt(residual)) +end + +"""Accept the candidate: the mask, the split-step collar, then the quadrature alarm.""" +function commit!(engine, dz::Float64) + c, w = engine.config, engine.work + mask!(engine, w.candidate) + if c.split_active + c.free ? split_free!(engine, dz) : split_modal!(engine, dz) + mask!(engine, w.candidate) + engine.fsal_valid = false + elseif !c.low_storage && w.adams === nothing + # The last stage's source is the next trial's first. + copyto!(@view(w.stages[:, :, 1]), w.source) + engine.fsal_valid = true + end + copyto!(w.y, w.candidate) + c.embedded ? quadrature_alarm(engine) : NaN +end + +function split_modal!(engine, dz) + c, w = engine.config, engine.work + (; coarse) = w + mul!(coarse, w.coarse_inverse, w.candidate) + rate = c.coarse_rate + T = real_type(engine) + # The unnormalised inverse's 1/nc is folded into the collar's factor. + half, inverse = T(-0.5 * dz), inv(T(c.nc)) + each!(c, size(coarse)...) do t, m + @inbounds coarse[t, m] *= exp(half * rate[t]) * inverse + end + mul!(w.candidate, w.coarse_forward, coarse) +end + +"""The embedded coarse quadrature's relative defect in the last stage's source.""" +function quadrature_alarm(engine) + c, w = engine.config, engine.work + mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) + w.plasma === nothing || add_plasma!(w.coarse_spec, w.plasma, w.forward_plan, c; coarse=true) + (; prefactor, omega_window, crop) = c + fine, coarse = w.fine, w.coarse_spec + T = real_type(engine) + sums = reduce_each(.+, (zero(T), zero(T)), c, size(w.y)...) do f, m + @inbounds begin + weight = prefactor[f, m] * omega_window[f] + exact = weight * fine[crop[f], m] + (abs2(exact), abs2(weight * coarse[crop[f], m] - exact)) + end + end + sums[1] == 0 ? NaN : Float64(sqrt(sums[2] / sums[1])) +end diff --git a/julia/src/free.jl b/julia/src/free.jl index 63b12dc97..ec6bf07ee 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -1,267 +1,277 @@ # SPDX-FileCopyrightText: 2026 John C. Travers and contributors # SPDX-License-Identifier: GPL-3.0-or-later -# Cartesian geometry keeps shared coefficient vectors and one current-stage flow. -# FFT/array planning is CPU-specific; the scalar loops and Kerr body are shared. -function create_free(common, input) - vector(name,T) = Vector{T}(input[name]) - shape = Tuple(Int.(input["spatial_shape"])) - c = merge(common, ( - parallel_copy=get(ENV,"SOLPROP_JULIA_PARALLEL_COPY","1")=="1", - spatial_shape=shape, pad_scale=Float64(input["pad_scale"]), - spatial_rate=vector("spatial_rate",Float64), - k_squared=vector("k_squared",ComplexF64), k_squared_low=vector("k_squared_low",ComplexF64), - kperp_sq=vector("kperp_sq",Float64), kperp_sq_low=vector("kperp_sq_low",Float64), - frame=vector("frame",Float64), spectral_rate=vector("spectral_rate",Float64), - prefactor_numerator=vector("prefactor_numerator",ComplexF64), - prefactor_clamped=vector("prefactor_clamped",ComplexF64), active=vector("active",Bool), - kperp_rate=vector("kperp_rate",Float64), evanescent_rate=Float64(input["evanescent_rate"]), +# Cartesian and line free space: the state is (n_omega, n_x n_y) in the transverse +# spectral basis; the response is evaluated in physical space, chunk by chunk of +# columns, and the operator is formed per element from separable tables. + +function create_free(c, host) + c = common_tables(c, host) + T, C = c.T, Complex{c.T} + shape = Tuple(Int.(host.value("spatial_shape"))) + nw, nm, nt, nf = length(host.array("crop", Int)), prod(shape), c.nt, c.nf + spatial_rate = host.array("spatial_rate", Float64) + # An exactly absent additive loss omits its transforms; the accepted-step split + # and the diagonal spectral loss are separate. + in_stage = any(!iszero, spatial_rate) || (!c.split && any(!iszero, c.rate)) + nc = length(c.coarse_rate) + # Both inverse transforms are unnormalised; their 1/(nt n_x n_y) goes into the + # factor that forms the physical field from them. + scale = inv(T(nt) * T(nm)) + op = ( + k_squared=upload(c, host.array("k_squared", C)), k_squared_low=upload(c, host.array("k_squared_low", C)), + kperp_sq=upload(c, host.array("kperp_sq", T)), kperp_sq_low=upload(c, host.array("kperp_sq_low", T)), + frame=upload(c, host.array("frame", T)), spectral_rate=upload(c, host.array("spectral_rate", T)), + prefactor_numerator=upload(c, host.array("prefactor_numerator", C)), + prefactor_clamped=upload(c, host.array("prefactor_clamped", C)), + active=upload(c, host.array("active", Bool)), kperp_rate=upload(c, host.array("kperp_rate", T)), + evanescent_rate=T(host.real("evanescent_rate")), + ) + c = merge(c, ( + spatial_shape=shape, op=op, field_scale=T(host.real("pad_scale")) * scale, + absorber_scale=T(-0.5) * scale, spatial_rate=upload(c, T.(spatial_rate)), + temporal_rate=upload(c, T.(c.split ? zero(c.rate) : c.rate)), in_stage=in_stage, + coarse_rate=upload(c, T.(c.coarse_rate)), nc=nc, embedded=false, )) - # Only an exactly absent additive source can omit these transforms. The - # accepted-step temporal split and the diagonal spectral loss are separate. - active_absorber = any(!iszero,c.spatial_rate) || (!c.split && any(!iszero,c.rate)) - c = merge(c, (in_stage_absorber=( - get(ENV,"SOLPROP_JULIA_SKIP_ZERO_ABSORBER","1") != "1" || active_absorber - ),)) - nw, nm, nt = length(c.crop), prod(shape), length(c.window) - chunk = min(Int(input["chunk"]),nm) - nf, nc = c.envelope ? nt : nt÷2+1, length(c.coarse_rate) - T = c.envelope ? ComplexF64 : Float64 - stages = c.low_storage ? 0 : length(c.c) - physical = zeros(ComplexF64,nw,nm) - spatial = view(reshape(physical,nw,shape...),:,:,:) - fine, modal = zeros(ComplexF64,nf,chunk), zeros(T,nt,chunk) - analytic = zeros(ComplexF64,nt,chunk) - coarse, coarse_spec = zeros(T,nc,chunk), zeros(ComplexF64,nw,chunk) - w = ( - plasma=plasma_workspace(input,c,nt,chunk,chunk,nm), - y=zeros(ComplexF64,nw,nm), candidate=zeros(ComplexF64,nw,nm), - lab=zeros(ComplexF64,nw,nm), source=zeros(ComplexF64,nw,nm), - fsal=zeros(ComplexF64,c.low_storage ? 0 : nw,c.low_storage ? 0 : nm), error=zeros(ComplexF64,nw,nm), - stages=zeros(ComplexF64,nw,nm,stages), - forward=zeros(ComplexF64,nw,nm,1), inverse=zeros(ComplexF64,nw,nm,c.low_storage ? 0 : 1), - physical=physical, loss=zeros(ComplexF64,nw,nm), - fine=fine, modal=modal, projected=zeros(T,nt,chunk), - analytic=analytic, absorber=zeros(T,nt,chunk), absorber_spec=similar(fine), - coarse=coarse, coarse_spec=coarse_spec, partials=zeros(3,nm), - spatial_inverse=plan_ifft!(spatial,(2,3);flags=c.fft_flags,num_threads=c.transverse_fft_threads), - spatial_forward=plan_fft!(spatial,(2,3);flags=c.fft_flags,num_threads=c.transverse_fft_threads), - inverse_plan=c.envelope ? plan_ifft(fft_storage(fine),1;flags=c.fft_flags) : plan_irfft(fft_storage(fine),nt,1;flags=c.fft_flags), - forward_plan=c.envelope ? plan_fft(fft_storage(modal),1;flags=c.fft_flags) : plan_rfft(fft_storage(modal),1;flags=c.fft_flags), - analytic_forward=plan_fft!(fft_storage(analytic),1;flags=c.fft_flags), - analytic_inverse=plan_ifft!(fft_storage(analytic),1;flags=c.fft_flags), - coarse_inverse=c.envelope ? plan_ifft(fft_storage(coarse_spec),1;flags=c.fft_flags) : plan_irfft(fft_storage(coarse_spec),nc,1;flags=c.fft_flags), - coarse_forward=c.envelope ? plan_fft(fft_storage(coarse),1;flags=c.fft_flags) : plan_rfft(fft_storage(coarse),1;flags=c.fft_flags), + chunk = min(host.int("chunk"), nm) + R = c.envelope ? C : T + stages = c.low_storage ? 0 : 7 + physical = dzeros(c, C, nw, nm) + spatial = reshape(physical, nw, shape...) + fine, modal = dzeros(c, C, nf, chunk), dzeros(c, R, nt, chunk) + analytic = dzeros(c, C, nt, chunk) + coarse, coarse_spec = dzeros(c, R, nc, chunk), dzeros(c, C, nw, chunk) + planes = (threads=c.transverse_fft_threads, shape=:planes) + work = ( + adams=nothing, path=nothing, raman=nothing, + plasma=plasma_workspace(c, host, nt, chunk, chunk, nm), + y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), + source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), + stages=dzeros(c, C, nw, nm, stages), + forward=dzeros(c, C, nw, nm, 1), inverse=dzeros(c, C, nw, nm, c.low_storage ? 0 : 1), + physical=physical, loss=dzeros(c, C, in_stage ? nw : 0, in_stage ? nm : 0), + fine=fine, modal=modal, projected=dzeros(c, R, nt, chunk), analytic=analytic, + absorber=dzeros(c, R, nt, chunk), absorber_spec=similar(fine), coarse=coarse, coarse_spec=coarse_spec, + spatial_inverse=plan(c, plan_bfft!, spatial, (2, 3); planes...), + spatial_forward=plan(c, plan_fft!, spatial, (2, 3); planes...), + inverse_plan=c.envelope ? plan(c, plan_bfft, fine, 1) : plan(c, plan_brfft, fine, nt, 1), + forward_plan=c.envelope ? plan(c, plan_fft, modal, 1) : plan(c, plan_rfft, modal, 1), + analytic_forward=plan(c, plan_fft!, analytic, 1), analytic_inverse=plan(c, plan_bfft!, analytic, 1), + coarse_inverse=c.envelope ? plan(c, plan_bfft, coarse_spec, 1) : plan(c, plan_brfft, coarse_spec, nc, 1), + coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), ) - Engine(c,w,false,0,NaN,c.factor) + Engine(c, work, false, 0, NaN, c.factor) end -# For an exactly real squared longitudinal wave number, the principal root is -# sqrt(x) for x>0 and i*sqrt(-x) for x<0. Preserve the imaginary signed zero and -# use the library complex root for lossy or nonfinite inputs. The compensated -# subtraction that forms q remains untouched; no near-zero cutoff is introduced. -@inline function free_root(q,specialize) - x,y=real(q),imag(q) - if specialize && iszero(y) && isfinite(x) - if x > 0 - return complex(sqrt(x),y) - elseif x < 0 - return complex(0.0,copysign(sqrt(-x),y)) - else - return complex(0.0,y) - end +# For an exactly real squared longitudinal wave number the principal root is sqrt(x) +# for x > 0 and i sqrt(-x) for x < 0, keeping the imaginary signed zero; a lossy or +# nonfinite input takes the library's complex root. No near-zero cutoff. +@inline function free_root(q) + x, y = real(q), imag(q) + if iszero(y) && isfinite(x) + x > 0 && return complex(sqrt(x), y) + x < 0 && return complex(zero(x), copysign(sqrt(-x), y)) + return complex(zero(x), y) end sqrt(q) end -# Preserve the compensated subtraction order in translate.spatial.longitudinal_root. -# No fast-math or reassociation: near grazing, the residual determines the branch. -@inline function free_element(c,f,m) +"""The element's linear rate and its prefactor, from the separable tables. + +The compensated subtraction that forms `q` keeps translate.spatial.longitudinal_root's +order: near grazing the residual decides the branch, so no reassociation here. +""" +@inline function free_element(op, f, m) @inbounds begin - q = (c.k_squared[f]-c.kperp_sq[m]) + (c.k_squared_low[f]-c.kperp_sq_low[m]) - root = free_root(q,c.real_root) + q = (op.k_squared[f] - op.kperp_sq[m]) + (op.k_squared_low[f] - op.kperp_sq_low[m]) + root = free_root(q) propagating = real(q) > 0 - attenuation = propagating ? imag(root) : min(abs(imag(root)),c.evanescent_rate) - rate = c.active[f] ? complex(-attenuation-0.5*c.kperp_rate[m],-(real(root)-c.frame[f])) : 0.0im - prefactor = propagating ? c.prefactor_numerator[f]/real(root) : c.prefactor_clamped[f] - return rate-0.5*c.spectral_rate[f], c.active[f] ? prefactor : 0.0im + attenuation = propagating ? imag(root) : min(abs(imag(root)), op.evanescent_rate) + live = op.active[f] + rate = live ? complex(-attenuation - op.kperp_rate[m] / 2, -(real(root) - op.frame[f])) : + zero(root) + prefactor = propagating ? op.prefactor_numerator[f] / real(root) : op.prefactor_clamped[f] + return rate - op.spectral_rate[f] / 2, live ? prefactor : zero(prefactor) end end -function free_propagators!(engine,h) - engine.propagator_dz == h && return - c,w = engine.config,engine.work - # The zero-distance stage is exactly identity; the final two DOPRI stages - # share a distance and can reuse this one scratch pair without dense caches. +"""Form the propagator pair of one distance in slot one; return the slot.""" +function free_propagators!(engine, h) + engine.propagator_dz == h && return 1 + c, w = engine.config, engine.work + (; forward, inverse) = w if h == 0 - fill!(w.forward,1) - fill!(w.inverse,1) - engine.propagator_dz = h - return - end - foreach_sample(w.y,c.tasks) do f,m,i - @inbounds begin - rate,_ = free_element(c,f,m) - exponent = h*rate - # Both signs share exact trigonometric inputs, as in the compiled seam. - scale = exp(real(exponent)) - sine,cosine = sincos(imag(exponent)) - w.forward[i] = scale*complex(cosine,sine) - if !c.low_storage - w.inverse[i] = complex(cosine,-sine)/scale + # The zero-distance stage is exactly the identity. + fill!(forward, 1) + fill!(inverse, 1) + else + op, both, distance = c.op, !c.low_storage, real_type(engine)(h) + each!(c, size(forward, 1), size(forward, 2)) do f, m + @inbounds begin + exponent = distance * first(free_element(op, f, m)) + # Both signs share exact trigonometric inputs, as in the compiled seam. + scale = exp(real(exponent)) + sine, cosine = sincos(imag(exponent)) + forward[f, m, 1] = scale * complex(cosine, sine) + both && (inverse[f, m, 1] = complex(cosine, -sine) / scale) end end end engine.propagator_dz = h - nothing + 1 end -# Large source-entry copies are bandwidth passes. Reuse the shared traversal -# and its task threshold without changing element order or owned storage. -function copy_volume!(destination,source,c) - if c.parallel_copy - foreach_sample(destination,c.tasks) do f,m,i - @inbounds destination[i]=source[i] +transverse!(a, plan, c) = (plan * reshape(a, size(a, 1), c.spatial_shape...); nothing) + +"""Copy columns `first:first+count-1` of `physical` into the fine spectrum.""" +function scatter_columns!(fine, physical, first, count, c) + uncrop = c.uncrop + each!(c, size(fine)...) do k, m + @inbounds begin + f = uncrop[k] + fine[k, m] = f == 0 || m > count ? zero(eltype(fine)) : physical[f, first+m-1] end - else - copyto!(destination,source) end - nothing -end - -function spatial_fft!(a,plan,c) - shaped = view(reshape(a,size(a,1),c.spatial_shape...),:,:,:) - fft_apply!(shaped,plan,shaped,c) - nothing end -function source_free!(engine,lab) - c,w = engine.config,engine.work - nt,chunk = size(w.modal) - nw,nm = size(lab) - copy_volume!(w.physical,lab,c) - spatial_fft!(w.physical,w.spatial_inverse,c) - # Transverse inversion precedes real temporal synthesis: individual transverse - # spectral columns do not themselves represent real temporal fields. +function source_free!(engine, lab) + c, w = engine.config, engine.work + (; physical, fine, modal, projected, analytic, loss) = w + nm = size(lab, 2) + chunk = size(modal, 2) + copyto!(physical, lab) + transverse!(physical, w.spatial_inverse, c) + # Transverse inversion first: a transverse spectral column alone is not the + # spectrum of a real temporal field. + scale, window, a = c.field_scale, c.window, c.analytic_factor + T = real_type(engine) + factor = T(c.factor) for first in 1:chunk:nm - count = min(chunk,nm-first+1) - fill!(w.fine,0) - foreach_sample(@view(w.physical[:,first:first+count-1]),c.tasks) do f,m,i - @inbounds w.fine[c.crop[f],m] = w.physical[f,first+m-1] - end - fft_apply!(w.modal,w.inverse_plan,w.fine,c) - if !isnothing(w.plasma) - # The temporal inverse is unscaled; plasma consumes SI nodal fields, - # with the same padding normalization as the Kerr response below. - foreach_sample(w.projected,c.tasks) do t,m,i - @inbounds w.projected[i]=c.pad_scale*w.modal[i] + count = min(chunk, nm - first + 1) + scatter_columns!(fine, physical, first, count, c) + mul!(modal, w.inverse_plan, fine) + if w.plasma !== nothing + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = scale * modal[t, m] end - plasma_current!(w.plasma,@view(w.projected[:,1:count]),c,first) + plasma_current!(w.plasma, projected, c, count) end if c.envelope - foreach_sample(w.projected,c.tasks) do t,m,i + each!(c, size(modal)...) do t, m @inbounds begin - value=c.pad_scale*w.modal[i] - w.projected[i] = c.factor*c.analytic_factor*abs2(value)*value*c.window[t] + v = scale * modal[t, m] + projected[t, m] = factor * a * abs2(v) * v * window[t] end end elseif c.analytic - foreach_sample(w.analytic,c.tasks) do t,m,i - @inbounds w.analytic[i] = c.pad_scale*w.modal[i] - end - w.analytic_forward*w.analytic - foreach_sample(w.analytic,c.tasks) do f,m,i - @inbounds w.analytic[i] *= (f == 1 || f == nt÷2+1) ? 1 : f <= nt÷2 ? 2 : 0 + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = scale * modal[t, m] end - fft_apply!(w.analytic,w.analytic_inverse,w.analytic,c) - polarize!(w.projected,w.analytic,c) + analytic_signal!(analytic, projected, w, c, chunk) + nonlinear_nodes!(projected, analytic, c, factor, nothing, chunk) else - foreach_sample(w.projected,c.tasks) do t,m,i - @inbounds w.projected[i] = polarization(c.pad_scale*w.modal[i],c.factor,c.analytic_factor)*c.window[t] - end - end - mul!(w.fine,w.forward_plan,w.projected) - # The held-current equivalent polarization combines before the spatial - # forward FFT, exactly as the reference Cartesian source does. - isnothing(w.plasma) || add_plasma!(w.fine,w.plasma,w.forward_plan,c;direct=true) - if c.in_stage_absorber - foreach_sample(w.absorber,c.tasks) do t,m,i - @inbounds begin - rate = m <= count ? c.spatial_rate[first+m-1] : 0.0 - rate += c.split ? 0.0 : c.rate[t] - w.absorber[i] = -0.5*rate*w.modal[i] - end - end - mul!(w.absorber_spec,w.forward_plan,w.absorber) - end - foreach_sample(@view(w.physical[:,first:first+count-1]),c.tasks) do f,m,i - @inbounds begin - w.physical[f,first+m-1] = w.fine[c.crop[f],m] - if c.in_stage_absorber - w.loss[f,first+m-1] = w.absorber_spec[c.crop[f],m] - end + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = polarization(scale * modal[t, m], factor, a) * window[t] end end + mul!(fine, w.forward_plan, projected) + # The held-current polarisation joins before the transverse forward transform, + # as the reference Cartesian source does. + w.plasma === nothing || add_plasma!(fine, w.plasma, w.forward_plan, c; direct=true) + c.in_stage && free_absorber!(w, c, first, count) + gather_columns!(physical, fine, c.in_stage ? loss : nothing, w.absorber_spec, first, count, c) end - spatial_fft!(w.physical,w.spatial_forward,c) - c.in_stage_absorber && spatial_fft!(w.loss,w.spatial_forward,c) - foreach_sample(w.source,c.tasks) do f,m,i + transverse!(physical, w.spatial_forward, c) + c.in_stage && transverse!(loss, w.spatial_forward, c) + (; source) = w + (; op, omega_window, mask) = c + live = c.in_stage + extra = live ? loss : physical + each!(c, size(source)...) do f, m @inbounds begin - _,prefactor = free_element(c,f,m) - w.source[i] = prefactor*c.omega_window[f]*w.physical[i] + (c.in_stage_absorber && c.mask[f] ? w.loss[i] : 0.0im) + value = last(free_element(op, f, m)) * omega_window[f] * physical[f, m] + if live && mask[f] + value += extra[f, m] + end + source[f, m] = value end end engine.calls += 1 nothing end -function split_free!(engine,dz) - c,w = engine.config,engine.work - copy_volume!(w.physical,w.candidate,c) - spatial_fft!(w.physical,w.spatial_inverse,c) - chunk = size(w.coarse,2) - for first in 1:chunk:size(w.candidate,2) - count = min(chunk,size(w.candidate,2)-first+1) - fill!(w.coarse_spec,0) - @views copyto!(w.coarse_spec[:,1:count],w.physical[:,first:first+count-1]) - fft_apply!(w.coarse,w.coarse_inverse,w.coarse_spec,c) - foreach_sample(w.coarse,c.tasks) do t,m,i - @inbounds w.coarse[i] *= exp(-0.5*dz*c.coarse_rate[t]) +"""The in-stage loss of a chunk's columns: their spatial collar and, unsplit, time's.""" +function free_absorber!(w, c, first, count) + (; absorber, modal) = w + spatial, temporal, scale = c.spatial_rate, c.temporal_rate, c.absorber_scale + each!(c, size(absorber)...) do t, m + @inbounds begin + rate = (m <= count ? spatial[first+m-1] : zero(scale)) + temporal[t] + absorber[t, m] = scale * rate * modal[t, m] + end + end + mul!(w.absorber_spec, w.forward_plan, absorber) +end + +function gather_columns!(physical, fine, loss, absorber_spec, first, count, c) + crop = c.crop + live = loss !== nothing + target = live ? loss : physical + each!(c, size(physical, 1), count) do f, m + @inbounds begin + k = crop[f] + physical[f, first+m-1] = fine[k, m] + live && (target[f, first+m-1] = absorber_spec[k, m]) end - mul!(w.coarse_spec,w.coarse_forward,w.coarse) - @views copyto!(w.physical[:,first:first+count-1],w.coarse_spec[:,1:count]) end - spatial_fft!(w.physical,w.spatial_forward,c) - copy_volume!(w.candidate,w.physical,c) - nothing end -# Reuse the accepted-field observation scan on bounded physical-space chunks. -function population_free_snapshot(engine,input) - c,w=engine.config,engine.work - p=w.plasma - copyto!(w.physical,Matrix{ComplexF64}(input)) - spatial_fft!(w.physical,w.spatial_inverse,c) - chunk=size(w.modal,2) - parts=zeros(6,chunk) - maxima=zeros(6) - for first in 1:chunk:size(w.physical,2) - count=min(chunk,size(w.physical,2)-first+1) - fill!(w.fine,0) - foreach_sample(@view(w.physical[:,first:first+count-1]),c.tasks) do f,m,i - @inbounds w.fine[c.crop[f],m]=w.physical[f,first+m-1] +function split_free!(engine, dz) + c, w = engine.config, engine.work + (; physical, coarse, coarse_spec) = w + copyto!(physical, w.candidate) + transverse!(physical, w.spatial_inverse, c) + chunk, nm, nw = size(coarse, 2), size(physical, 2), size(physical, 1) + T = real_type(engine) + rate, half = c.coarse_rate, T(-0.5 * dz) + # Both unnormalised inverses' 1/(nc n_x n_y) is folded into the collar's factor. + inverse = inv(T(c.nc) * T(nm)) + for first in 1:chunk:nm + count = min(chunk, nm - first + 1) + each!(c, size(coarse_spec)...) do f, m + @inbounds coarse_spec[f, m] = m <= count ? physical[f, first+m-1] : zero(eltype(coarse_spec)) end - fft_apply!(w.modal,w.inverse_plan,w.fine,c) - foreach_sample(w.projected,c.tasks) do t,m,i - @inbounds w.projected[i]=c.pad_scale*w.modal[i] + mul!(coarse, w.coarse_inverse, coarse_spec) + each!(c, size(coarse)...) do t, m + @inbounds coarse[t, m] *= exp(half * rate[t]) * inverse end - nodes=@view(w.projected[:,1:count]) - AK.foreachindex(1:count;max_tasks=c.tasks,min_elems=1) do node - population_column!(p,nodes,node,first,parts) + mul!(coarse_spec, w.coarse_forward, coarse) + each!(c, nw, count) do f, m + @inbounds physical[f, first+m-1] = coarse_spec[f, m] end - @inbounds for node in 1:count, i in 1:6 - maxima[i]=max(maxima[i],parts[i,node]) + end + transverse!(physical, w.spatial_forward, c) + copyto!(w.candidate, physical) + nothing +end + +function population_free_snapshot(engine, input) + c, w = engine.config, engine.work + p = w.plasma + (; physical, fine, modal, projected) = w + copyto!(physical, device_matrix(engine, input)) + transverse!(physical, w.spatial_inverse, c) + chunk, nm = size(modal, 2), size(physical, 2) + scale = c.field_scale + maxima = zeros(6) + for first in 1:chunk:nm + count = min(chunk, nm - first + 1) + scatter_columns!(fine, physical, first, count, c) + mul!(modal, w.inverse_plan, fine) + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = scale * modal[t, m] end + maxima .= max.(maxima, population_parts!(p, projected, c, first, count)) end - (copy(p.fractions),copy(p.peaks),maxima) + (Vector{Float64}(Array(p.fractions)), Vector{Float64}(Array(p.peaks)), maxima) end diff --git a/julia/src/launch.jl b/julia/src/launch.jl new file mode 100644 index 000000000..898c609ee --- /dev/null +++ b/julia/src/launch.jl @@ -0,0 +1,134 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The device layer: everything that differs between a CPU and a GPU is here. + +"""Read the settings a Python dict carries, once, at construction.""" +function HostInput(input) + has(key) = haskey(input, key) + (has=has, int=key -> Int(input[key]), real=key -> Float64(input[key]), + flag=key -> has(key) && Bool(input[key]), string=key -> String(input[key]), + array=(key, T) -> Array{T}(input[key]), value=key -> input[key]) +end + +device_backend(::Val{:cpu}) = KA.CPU() +device_backend(::Val{D}) where {D} = + throw(ArgumentError("device $D needs its package loaded first (SOLPROP_JULIA_DEVICE)")) +device_label(::KA.CPU) = "cpu" +oncpu(c) = c.backend isa KA.CPU + +"""Put a host array on the engine's device, owning it on the CPU too.""" +upload(::KA.CPU, a::Array) = a +upload(backend, a::Array) = copyto!(KA.allocate(backend, eltype(a), size(a)), a) +upload(c::NamedTuple, a::Array) = upload(c.backend, a) +dzeros(c, T, dims...) = KA.zeros(c.backend, T, dims...) + +# Below this many samples one pass is faster on one thread than split over tasks +# (julia/bench/launch.jl: a Kerr pass over 10240 x 4 takes 8.5 us on one thread of the +# Xeon, 10.5 us on four). +const PARALLEL_SAMPLES = 65536 + +"""Call `f(t, m)` for every sample of an `nt` x `nm` column-major array. + +On a CPU each task takes whole columns, or pieces of one when there are fewer columns +than tasks, and runs a contiguous `@simd` loop over its rows: an index divide per +sample costs a factor of ten (julia/bench/launch.jl). On a GPU each sample is a thread. +""" +@inline each!(f::F, c, nt::Integer, nm::Integer) where {F} = + each_on!(f, c.backend, c.tasks, Int(nt), Int(nm)) + +function each_on!(f::F, ::KA.CPU, tasks, nt, nm) where {F} + pieces, rows = tiling(tasks, nt, nm) + if pieces * nm == 1 + @inbounds @simd for t in 1:nt + @inline f(t, 1) + end + return nothing + end + AK.foreachindex(1:pieces*nm; max_tasks=tasks, min_elems=1) do k + m = (k - 1) ÷ pieces + 1 + first = (k - (m - 1) * pieces - 1) * rows + 1 + @inbounds @simd for t in first:min(first + rows - 1, nt) + @inline f(t, m) + end + end + nothing +end + +"""Split `nt` x `nm` samples into column pieces: one task's worth each.""" +function tiling(tasks, nt, nm) + if tasks == 1 || nt * nm < PARALLEL_SAMPLES + return 1, nt + end + nm >= tasks && return 1, nt + pieces = min(cld(tasks, nm), cld(nt * nm, PARALLEL_SAMPLES ÷ 4)) + pieces, cld(nt, pieces) +end + +KA.@kernel inbounds = true function each_kernel!(f) + t, m = KA.@index(Global, NTuple) + f(t, m) +end +function each_on!(f::F, backend, tasks, nt, nm) where {F} + each_kernel!(backend, (256, 1))(f; ndrange=(nt, nm)) + nothing +end + +"""Call `f(m)` for each of `nm` columns, whose body runs sequentially down one.""" +function each_column!(f::F, c, nm::Integer) where {F} + if oncpu(c) + AK.foreachindex(1:Int(nm); max_tasks=c.tasks, min_elems=1) do m + @inline f(m) + end + else + AK.foreachindex(f, 1:Int(nm); backend=c.backend, block_size=64) + end + nothing +end + +"""Return `op` folded over `f(t, m)` for every sample, starting from `neutral`. + +`op` must be associative and commutative: the order is the tiling's (CPU) or the +reduction tree's (GPU), and differs with the width (SEP 25 bounds it, not bits). +""" +function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer) where {F,O} + nt, nm = Int(nt), Int(nm) + if oncpu(c) + pieces, rows = tiling(c.tasks, nt, nm) + partials = fill(neutral, pieces * nm) + AK.foreachindex(1:pieces*nm; max_tasks=c.tasks, min_elems=1) do k + m = (k - 1) ÷ pieces + 1 + first = (k - (m - 1) * pieces - 1) * rows + 1 + value = neutral + @inbounds for t in first:min(first + rows - 1, nt) + value = op(value, f(t, m)) + end + @inbounds partials[k] = value + end + return foldl(op, partials; init=neutral) + end + AK.mapreduce(op, 1:nt*nm; backend=c.backend, init=neutral, neutral=neutral) do i + m = (i - 1) ÷ nt + 1 + f(i - (m - 1) * nt, m) + end +end + +# FFTW's planner: native's policy (native/include/solprop_native/fft_plan.hpp). Serial +# row transforms and every transverse plane are measured, threaded rows estimated (a +# measured threaded plan was slower there); SOLPROP_FFTW_PLAN overrides all of them. +const FLAGS = Dict("estimate" => FFTW.ESTIMATE, "measure" => FFTW.MEASURE, + "patient" => FFTW.PATIENT) +function plan_flags(shape::Symbol, threads) + chosen = get(ENV, "SOLPROP_FFTW_PLAN", "") + isempty(chosen) && return shape === :rows && threads > 1 ? FFTW.ESTIMATE : FFTW.MEASURE + haskey(FLAGS, chosen) || throw(ArgumentError("SOLPROP_FFTW_PLAN must be estimate, measure or patient")) + FLAGS[chosen] +end + +"""Plan `kind(a, args...)` for the engine's device; inverses are left unnormalised. + +On a CPU, measuring overwrites `a`: plan before anything is stored in it. +""" +plan(c, kind, a, args...; threads=c.fft_threads, shape=:rows) = + oncpu(c) ? kind(a, args...; flags=plan_flags(shape, threads), num_threads=threads) : + kind(a, args...) diff --git a/julia/src/modal.jl b/julia/src/modal.jl new file mode 100644 index 000000000..7afeea702 --- /dev/null +++ b/julia/src/modal.jl @@ -0,0 +1,189 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Modal and radial routes: the state is (n_omega, n_modes); the response is evaluated +# at the transform's nodes, chunk by chunk, and projected back onto the modes. + +"""Settings and buffers both routes share: band, windows, tableau, controller.""" +function common_tables(c, host) + T = c.T + crop = host.array("crop", Int) .+ 1 + nt = length(host.array("window", Float64)) + nf = c.envelope ? nt : nt ÷ 2 + 1 + # Which band bin feeds each fine bin, zero for the padding: scattering a stage + # into the fine spectrum is then one pass that also clears the padding. + uncrop = zeros(Int, nf) + uncrop[crop] .= eachindex(crop) + merge(c, ( + crop=upload(c, crop), uncrop=upload(c, uncrop), + mask=upload(c, host.array("mask", Bool)), norm_mask=upload(c, host.array("norm_mask", Bool)), + weights=upload(c, host.array("weights", T)), uniform=all(==(1), host.array("weights", Float64)), + window=upload(c, host.array("window", T)), omega_window=upload(c, host.array("omega_window", T)), + rate=host.array("rate", Float64), coarse_rate=host.array("coarse_rate", Float64), + a=host.array("a", Float64), b=host.array("b", Float64), e=host.array("e", Float64), + nodes_c=host.array("c", Float64), nt=nt, nf=nf, + split_active=c.split && any(!iszero, host.array("coarse_rate", Float64)), + )) +end + +function create_modal(c, host) + c = common_tables(c, host) + T, C = c.T, Complex{c.T} + nt, nf = c.nt, c.nf + synthesis = host.array("synthesis", Float64) + spatial = host.has("spatial_absorber") ? host.array("spatial_absorber", Float64) : zeros(0, 0) + # The translated rates are constant over a trial: an exactly absent loss needs no + # additive temporal transform; the accepted-step split stays separate. + in_stage = any(!iszero, spatial) || (!c.split && any(!iszero, c.rate)) + nw, nm = size(host.array("linear", ComplexF64)) + nn = size(synthesis, 2) + chunk = min(host.int("chunk"), nn) + R = c.envelope ? C : T + # Every inverse transform is unnormalised: its 1/nt is folded into the tables that + # read the time-domain field, the synthesis and the in-stage absorber. + c = merge(c, ( + linear=upload(c, host.array("linear", C)), prefactor=upload(c, host.array("prefactor", C)), + synthesis=upload(c, T.(synthesis ./ nt)), projection=upload(c, host.array("projection", T)), + projection_coarse=upload(c, host.array("projection_coarse", T)), + embedded=host.flag("embedded"), spatial_absorber=upload(c, T.(spatial ./ nt)), + in_stage=in_stage, absorber_rate=upload(c, T.(-0.5 .* c.rate ./ nt)), + coarse_rate=upload(c, T.(c.coarse_rate)), nc=length(c.coarse_rate), + )) + ns = length(c.nodes_c) + fine = dzeros(c, C, nf, nm) + modal = dzeros(c, R, nt, nm) + nodes = dzeros(c, R, nt, chunk) + analytic = dzeros(c, C, nt, chunk) + coarse = dzeros(c, R, c.nc, nm) + band = dzeros(c, C, nw, nm) + work = ( + adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), + raman=raman_workspace(c, host, nt, chunk), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), + y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), + source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), + stages=dzeros(c, C, nw, nm, ns), forward=dzeros(c, C, nw, nm, ns), inverse=dzeros(c, C, nw, nm, ns), + fine=fine, modal=modal, nodes=nodes, analytic=analytic, + projected=dzeros(c, R, nt, nm), projected_coarse=dzeros(c, R, nt, nm), coarse_spec=similar(fine), + absorber=dzeros(c, R, nt, nm), absorber_spec=similar(fine), coarse=coarse, + inverse_plan=c.envelope ? plan(c, plan_bfft, fine, 1) : plan(c, plan_brfft, fine, nt, 1), + forward_plan=c.envelope ? plan(c, plan_fft, modal, 1) : plan(c, plan_rfft, modal, 1), + analytic_forward=plan(c, plan_fft!, analytic, 1), analytic_inverse=plan(c, plan_bfft!, analytic, 1), + coarse_inverse=c.envelope ? plan(c, plan_bfft, band, 1) : plan(c, plan_brfft, band, c.nc, 1), + coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), + ) + Engine(c, work, false, 0, NaN, c.factor) +end + +"""Place a band-limited state in the fine spectrum, clearing the padding.""" +function scatter!(fine, lab, c) + uncrop = c.uncrop + each!(c, size(fine)...) do k, m + @inbounds begin + f = uncrop[k] + fine[k, m] = f == 0 ? zero(eltype(fine)) : lab[f, m] + end + end +end + +"""Evaluate the translated source of `lab` into `work.source`.""" +function source!(engine, lab; quadrature=false) + c, w = engine.config, engine.work + c.free && return source_free!(engine, lab) + nm = size(lab, 2) + scatter!(w.fine, lab, c) + mul!(w.modal, w.inverse_plan, w.fine) + fill!(w.projected, 0) + quadrature && fill!(w.projected_coarse, 0) + clear_plasma!(w.plasma) + if engine.factor != 0 || w.plasma !== nothing || w.raman !== nothing + chunk, nn = size(w.nodes, 2), size(c.synthesis, 2) + for first in 1:chunk:nn + last = min(first + chunk - 1, nn) + count = last - first + 1 + nodes = @view w.nodes[:, 1:count] + mul!(nodes, w.modal, @view(c.synthesis[:, first:last])) + if w.plasma !== nothing + plasma_current!(w.plasma, w.nodes, c, count) + project_plasma!(w.plasma, c, first, last, quadrature) + end + node_response!(engine, count) + mul!(w.projected, nodes, @view(c.projection[first:last, :]), true, true) + quadrature && c.embedded && + mul!(w.projected_coarse, nodes, @view(c.projection_coarse[first:last, :]), true, true) + end + end + mul!(w.fine, w.forward_plan, w.projected) + w.plasma === nothing || add_plasma!(w.fine, w.plasma, w.forward_plan, c) + if c.in_stage + absorber!(w.absorber, w.modal, c) + isempty(c.spatial_absorber) || mul!(w.absorber, w.modal, c.spatial_absorber, true, true) + mul!(w.absorber_spec, w.forward_plan, w.absorber) + end + finish_source!(w.source, w.fine, c.in_stage ? w.absorber_spec : nothing, c) + engine.calls += 1 + nothing +end + +"""Kerr and Raman at a chunk's nodes, through the analytic signal where one is read.""" +function node_response!(engine, count) + c, w = engine.config, engine.work + nodes, raman = w.nodes, w.raman + if c.envelope + raman === nothing || raman_drive!(raman, nodes, nodes, c, count) + nonlinear_envelope!(nodes, c, engine.factor, raman, count) + elseif c.analytic || (raman !== nothing && !raman.thg) + analytic_signal!(w.analytic, nodes, w, c, count) + raman === nothing || raman_drive!(raman, nodes, w.analytic, c, count) + nonlinear_nodes!(nodes, c.analytic ? w.analytic : nodes, c, engine.factor, raman, count) + else + raman === nothing || raman_drive!(raman, nodes, nodes, c, count) + nonlinear_nodes!(nodes, nodes, c, engine.factor, raman, count) + end +end + +"""The in-stage temporal collar's loss, `-alpha(t) E / 2`, unless the step splits it.""" +function absorber!(absorber, modal, c) + if c.split + fill!(absorber, 0) + else + rate = c.absorber_rate + each!(c, size(absorber)...) do t, m + @inbounds absorber[t, m] = rate[t] * modal[t, m] + end + end +end + +"""Scale the fine spectrum back onto the band: the prefactor and the omega window.""" +function finish_source!(source, fine, loss, c) + (; prefactor, omega_window, crop, mask) = c + live = loss !== nothing + extra = live ? loss : fine + each!(c, size(source)...) do f, m + @inbounds begin + k = crop[f] + value = prefactor[f, m] * omega_window[f] * fine[k, m] + if live && mask[f] + value += extra[k, m] + end + source[f, m] = value + end + end +end + +"""Observation populations of an accepted state: fractions, peaks and the six maxima.""" +function population_snapshot(engine, input) + engine.config.free && return population_free_snapshot(engine, input) + c, w = engine.config, engine.work + p = w.plasma + scatter!(w.fine, device_matrix(engine, input), c) + mul!(w.modal, w.inverse_plan, w.fine) + chunk, nn = size(w.nodes, 2), size(c.synthesis, 2) + maxima = zeros(6) + for first in 1:chunk:nn + last = min(first + chunk - 1, nn) + count = last - first + 1 + mul!(@view(w.nodes[:, 1:count]), w.modal, @view(c.synthesis[:, first:last])) + maxima .= max.(maxima, population_parts!(p, w.nodes, c, first, count)) + end + (Vector{Float64}(Array(p.fractions)), Vector{Float64}(Array(p.peaks)), maxima) +end diff --git a/julia/src/responses.jl b/julia/src/responses.jl index fb86dbf3a..bb87f91a2 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -1,320 +1,346 @@ # SPDX-FileCopyrightText: 2026 John C. Travers and contributors # SPDX-License-Identifier: GPL-3.0-or-later -# Numerical execution of the translated scalar response. Rate tables, constants, -# FIR taps and temporal collar derivatives all come from schema 34 (SEP 18/27). -function plasma_workspace(input, c, nt, chunk, nm, nn) - (haskey(input,"plasma") && Bool(input["plasma"])) || return nothing - # Cartesian columns already are physical nodes. Only their current chunk - # needs temporal current spectra; no modal projection buffers are required. - projected_rows, projected_columns = c.free ? (0,0) : (nt,nm) +# The translated scalar responses: Kerr, one field-plasma channel and one Raman term. +# Rate tables, constants, FIR taps and collar derivatives all come from the seam. + +@inline polarization(value::Real, factor, analytic_factor) = factor * (value * value) * value +@inline polarization(value::Complex, factor, analytic_factor) = + factor * analytic_factor * abs2(value) * real(value) + +"""Write the Kerr and Raman polarisation of each node's field over it, windowed. + +`values` is what the Kerr term reads: the field, or its analytic signal. Raman, when +present, multiplies the field by its convolved drive (`raman_drive!`). +""" +function nonlinear_nodes!(nodes, values, c, factor, raman, count) + window, a = c.window, c.analytic_factor + T = eltype(window) + f = T(factor) + if raman === nothing + each!(c, size(nodes, 1), count) do t, m + @inbounds nodes[t, m] = polarization(values[t, m], f, a) * window[t] + end + else + drive, r = raman.drive, T(raman.factor) + each!(c, size(nodes, 1), count) do t, m + @inbounds begin + v = nodes[t, m] + nodes[t, m] = (polarization(values[t, m], f, a) + r * v * drive[t, m]) * window[t] + end + end + end +end + +function nonlinear_envelope!(nodes, c, factor, raman, count) + window = c.window + T = eltype(window) + f = T(factor) * c.analytic_factor + r = raman === nothing ? zero(T) : T(raman.factor) + drive = raman === nothing ? nodes : raman.drive + live = raman !== nothing + each!(c, size(nodes, 1), count) do t, m + @inbounds begin + v = nodes[t, m] + response = f * abs2(v) * v + if live + response += r * v * real(drive[t, m]) + end + nodes[t, m] = response * window[t] + end + end +end + +"""Replace `analytic` by the analytic signal of the real columns of `nodes`.""" +function analytic_signal!(analytic, nodes, w, c, count) + nt, chunk = size(analytic) + each!(c, nt, chunk) do t, m + @inbounds analytic[t, m] = m <= count ? nodes[t, m] : 0 + end + w.analytic_forward * analytic + # The unnormalised inverse's 1/nt is folded into the one-sided spectral factor. + T = real(eltype(analytic)) + one, two, half = inv(T(nt)), 2 / T(nt), nt ÷ 2 + each!(c, nt, chunk) do f, m + @inbounds analytic[f, m] *= (f == 1 || f == half + 1) ? one : f <= half ? two : zero(T) + end + w.analytic_inverse * analytic + nothing +end + +# --- plasma ------------------------------------------------------------------------- + +function plasma_workspace(c, host, nt, chunk, nm, nn) + host.flag("plasma") || return nothing + T = c.T + columns = c.free ? 0 : nm ( - coefficients=Matrix{Float64}(input["plasma_coefficients"]), - parameters=Vector{Float64}(input["plasma_parameters"]), - taps=Vector{Float64}(input["plasma_taps"]), floor=Bool(input["plasma_floor"]), - dt=Float64(input["dt"]), omega=Vector{Float64}(input["omega"]), - derivative=Vector{Float64}(input["window_derivative"]), - rate=zeros(nt,chunk), fraction=zeros(nt,chunk), integrand=zeros(nt,chunk), - current=zeros(nt,chunk), gated=zeros(nt,chunk), edge=zeros(nt,chunk), - projected=zeros(projected_rows,projected_columns), edge_projected=zeros(projected_rows,projected_columns), - coarse=zeros(projected_rows,projected_columns), coarse_edge=zeros(projected_rows,projected_columns), - spectrum=zeros(ComplexF64,nt÷2+1,nm), edge_spectrum=zeros(ComplexF64,nt÷2+1,nm), - fractions=zeros(nn), peaks=zeros(nn), + coefficients=upload(c, host.array("plasma_coefficients", T)), + # Field range, rate cap, log-table origin and step, charge-mass ratio and + # ionisation potential; density and preionisation are a stage's (stages.jl). + parameters=host.array("plasma_parameters", Float64), + taps=upload(c, host.array("plasma_taps", T)), floor=host.flag("plasma_floor"), + dt=T(host.real("dt")), + inverse_omega=upload(c, T.(inv.(host.array("omega", Float64)))), + derivative=upload(c, host.array("window_derivative", T)), + rate=dzeros(c, T, nt, chunk), fraction=dzeros(c, T, nt, chunk), + integrand=dzeros(c, T, nt, chunk), current=dzeros(c, T, nt, chunk), + gated=dzeros(c, T, nt, chunk), edge=dzeros(c, T, nt, chunk), + projected=dzeros(c, T, nt, columns), edge_projected=dzeros(c, T, nt, columns), + coarse=dzeros(c, T, nt, columns), coarse_edge=dzeros(c, T, nt, columns), + spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, c.free ? chunk : nm), + edge_spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, c.free ? chunk : nm), + fractions=dzeros(c, T, nn), peaks=dzeros(c, T, nn), parts=dzeros(c, T, 6, chunk), ) end -@inline function rate_value(value, p) - x=abs(value) - x < p.parameters[1] && return 0.0 - x >= p.parameters[2] && return p.parameters[3] - logarithm=log(x) - delta=logarithm-p.parameters[4] - j=clamp(floor(Int,delta/p.parameters[5])+1,1,size(p.coefficients,2)) - t=logarithm-(p.parameters[4]+(j-1)*p.parameters[5]) - @inbounds value=((p.coefficients[1,j]*t+p.coefficients[2,j])*t+p.coefficients[3,j])*t+p.coefficients[4,j] - min(exp(value),p.parameters[3]) +"""The piecewise-cubic ionisation rate in log |E|, clamped to the table's range.""" +@inline function rate_value(value, table, lower, upper, cap, origin, step) + x = abs(value) + x < lower && return zero(cap) + x >= upper && return cap + logarithm = log(x) + j = clamp(unsafe_trunc(Int, floor((logarithm - origin) / step)) + 1, 1, size(table, 2)) + s = logarithm - (origin + (j - 1) * step) + @inbounds value = ((table[1, j] * s + table[2, j]) * s + table[3, j]) * s + table[4, j] + min(exp(value), cap) end +@inline rate_arguments(p) = (p.coefficients, ntuple(k -> typeof(p.dt)(p.parameters[k]), 5)...) -# A symmetric FIR followed by a running trapezoid. Point reflection preserves -# the endpoint convention of RunningIntegral; no reassociation of this scan. -@inline function filtered(values,t,node,taps) - nt=size(values,1) - @inbounds value=taps[1]*values[t,node] +# A symmetric FIR, reflected at the ends as RunningIntegral is, then a running +# trapezoid. The scan's order is strict: no reassociation. +@inline function filtered(values, t, node, taps) + nt = size(values, 1) + @inbounds value = taps[1] * values[t, node] @inbounds for k in 1:length(taps)-1 - left=t-k < 1 ? 2*values[1,node]-values[1+k-t+1,node] : values[t-k,node] - right=t+k > nt ? 2*values[nt,node]-values[2nt-t-k,node] : values[t+k,node] - value += taps[k+1]*(left+right) + left = t - k < 1 ? 2 * values[1, node] - values[1+k-t+1, node] : values[t-k, node] + right = t + k > nt ? 2 * values[nt, node] - values[2nt-t-k, node] : values[t+k, node] + value += taps[k+1] * (left + right) end value end -function integrate_column!(out,values,node,p) - previous=filtered(values,1,node,p.taps) - total=0.0 - @inbounds out[1,node]=0.0 - @inbounds for t in 2:size(values,1) - current=filtered(values,t,node,p.taps) - total += p.dt*(current+previous)/2 - out[t,node]=total - previous=current - end -end -# On CPU, filter independent time samples before the dependent prefix. Keeping -# the tap loop outside the interior time loop exposes SIMD without reordering -# a sample's tap additions. The output itself is scratch until the strict scan, -# so this traversal does not add a persistent buffer. -# Exact zero support saves filter and prefix work outside the live interval. -# Reflection cannot extend this interval beyond the filter radius: its endpoint -# is already live whenever a reflected endpoint value is nonzero. -function integrate_column!(out::StridedMatrix,values::StridedMatrix,node,p) - nt=size(values,1) - half=length(p.taps)-1 - first=1 - @inbounds while first <= nt && iszero(values[first,node]) +"""Integrate one column of `values` into `out`, sequentially down the column. + +Exact zero support is skipped: reflection cannot carry the live interval past the +filter's radius, since its endpoint is then live already. Interior samples apply the +taps one at a time over the whole interval, which a CPU vectorises without reordering +any one sample's additions. +""" +@inline function integrate_column!(out, values, node, taps, dt) + nt = size(values, 1) + half = length(taps) - 1 + first, last = 1, nt + @inbounds while first <= nt && iszero(values[first, node]) first += 1 end - fill!(@view(out[:,node]),0) - first > nt && return nothing - last=nt - @inbounds while iszero(values[last,node]) + if first > nt + @inbounds for t in 1:nt + out[t, node] = 0 + end + return nothing + end + @inbounds while iszero(values[last, node]) last -= 1 end - first=max(1,first-half) - last=min(nt,last+half) - if 2half >= nt - @inbounds for t in first:last - out[t,node]=filtered(values,t,node,p.taps) - end - else - @inbounds for t in first:min(half,last) - out[t,node]=filtered(values,t,node,p.taps) - end - @inbounds for t in max(nt-half+1,first):last - out[t,node]=filtered(values,t,node,p.taps) - end - interior_first=max(first,half+1) - interior_last=min(last,nt-half) - @inbounds @simd for t in interior_first:interior_last - out[t,node]=p.taps[1]*values[t,node] + first, last = max(1, first - half), min(nt, last + half) + @inbounds for t in 1:first-1 + out[t, node] = 0 + end + interior_first, interior_last = max(first, half + 1), min(last, nt - half) + @inbounds for t in first:last + if t < interior_first || t > interior_last + out[t, node] = filtered(values, t, node, taps) + else + out[t, node] = taps[1] * values[t, node] end - @inbounds for k in 1:half - tap=p.taps[k+1] - @simd for t in interior_first:interior_last - out[t,node] += tap*(values[t-k,node]+values[t+k,node]) - end + end + @inbounds for k in 1:half + tap = taps[k+1] + @simd for t in interior_first:interior_last + out[t, node] += tap * (values[t-k, node] + values[t+k, node]) end end - @inbounds previous=out[1,node] - total=0.0 - @inbounds out[1,node]=0.0 - stop=min(nt,last+1) - @inbounds for t in max(2,first):stop - current=out[t,node] - total += p.dt*(current+previous)/2 - out[t,node]=total - previous=current + @inbounds previous = out[1, node] + total = zero(dt) + @inbounds out[1, node] = 0 + stop = min(nt, last + 1) + @inbounds for t in max(2, first):stop + current = out[t, node] + total += dt * (current + previous) / 2 + out[t, node] = total + previous = current end @inbounds for t in stop+1:nt - out[t,node]=total + out[t, node] = total end nothing end -function plasma_current!(p,nodes,c,first) - AK.foreachindex(axes(nodes,2);max_tasks=c.tasks,min_elems=1) do node - peak=exposure_column!(p,nodes,node) - # With exactly zero rates and no initial electrons, both current streams - # vanish. Clear their outputs even if this chunk ionised on a prior call. - # The unused integrand/current scratch is overwritten on every live call. - if c.skip_zero_plasma && iszero(peak) && iszero(p.parameters[9]) - fill!(@view(p.gated[:,node]),0) - fill!(@view(p.edge[:,node]),0) - @inbounds p.fractions[first+node-1]=0.0 - @inbounds p.peaks[first+node-1]=0.0 - return - end - previous_exposure=NaN - fraction=0.0 - @inbounds for t in axes(nodes,1) - exposure=p.floor ? max(p.fraction[t,node],0.0) : p.fraction[t,node] - # An unchanged prefix gives the same fraction, including the exact - # zero-rate head and constant tail. No threshold or approximation. - if exposure != previous_exposure - fraction=1-(1-p.parameters[9])*exp(-exposure) - previous_exposure=exposure - end - p.fraction[t,node]=fraction - p.integrand[t,node]=fraction*p.parameters[6]*nodes[t,node] - end - integrate_column!(p.current,p.integrand,node,p) - @inbounds for t in axes(nodes,1) - field=nodes[t,node] - squared=field*field - loss=p.rate[t,node] > 0 && squared > 0 ? (p.parameters[7]*p.rate[t,node]*(1-p.fraction[t,node])/squared)*field : 0.0 - current=p.parameters[8]*(p.current[t,node]+loss) - p.gated[t,node]=c.window[t]*current - p.edge[t,node]=p.derivative[t]*current - end - @inbounds p.fractions[first+node-1]=p.fraction[size(nodes,1),node] - @inbounds p.peaks[first+node-1]=peak - end -end -function clear_plasma!(p) - isnothing(p) && return - for a in (p.projected,p.edge_projected,p.coarse,p.coarse_edge) - fill!(a,0) +"""One column's rates and exposure; return the peak rate.""" +@inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args) + peak = zero(dt) + @inbounds for t in axes(nodes, 1) + value = rate_value(nodes[t, node], args...) + rate[t, node] = value + peak = max(peak, value) end + integrate_column!(exposure, rate, node, taps, dt) + peak end -function project_plasma!(p,c,first,last,quadrature) - count=last-first+1 - for (values,full,coarse) in ((p.gated,p.projected,p.coarse),(p.edge,p.edge_projected,p.coarse_edge)) - mul!(full,@view(values[:,1:count]),@view(c.projection[first:last,:]),1.0,1.0) - if quadrature && c.embedded - mul!(coarse,@view(values[:,1:count]),@view(c.projection_coarse[first:last,:]),1.0,1.0) + +"""The plasma current of each node of a chunk, gated by the window and the collar.""" +function plasma_current!(p, nodes, c, count) + T = typeof(p.dt) + (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative) = p + window, floor = c.window, p.floor + args = rate_arguments(p) + charge, potential = T(p.parameters[6]), T(p.parameters[7]) + density, initial = T(p.parameters[8]), T(p.parameters[9]) + nt = size(nodes, 1) + each_column!(c, count) do node + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args) + # With exactly zero rates and no initial electrons both currents vanish. + if iszero(peak) && iszero(initial) + @inbounds for t in 1:nt + gated[t, node] = 0 + edge[t, node] = 0 + end + return nothing end - end -end -function add_plasma!(destination,p,plan,c;coarse=false,direct=false) - mul!(p.spectrum,plan,direct ? p.gated : coarse ? p.coarse : p.projected) - mul!(p.edge_spectrum,plan,direct ? p.edge : coarse ? p.coarse_edge : p.edge_projected) - foreach_sample(@view(destination[1:length(c.crop),:]),c.tasks) do f,m,i - @inbounds if c.mask[f] - k=c.crop[f] - inverse=1/p.omega[f] - destination[k,m] += -im*inverse*p.spectrum[k,m]+inverse^2*p.edge_spectrum[k,m] + previous, value = T(NaN), zero(T) + @inbounds for t in 1:nt + exposure = floor ? max(fraction[t, node], zero(T)) : fraction[t, node] + # An unchanged prefix gives the same fraction: the zero-rate head and the + # constant tail cost no exponential. No threshold, no approximation. + if exposure != previous + value = 1 - (1 - initial) * exp(-exposure) + previous = exposure + end + fraction[t, node] = value + integrand[t, node] = value * charge * nodes[t, node] + end + integrate_column!(current, integrand, node, taps, dt) + @inbounds for t in 1:nt + field = nodes[t, node] + squared = field * field + loss = rate[t, node] > 0 && squared > 0 ? + (potential * rate[t, node] * (1 - fraction[t, node]) / squared) * field : zero(T) + total = density * (current[t, node] + loss) + gated[t, node] = window[t] * total + edge[t, node] = derivative[t] * total end + nothing end end -# The source and observation share the translated rate and strict exposure scan. -function exposure_column!(p,nodes,node) - peak=0.0 - @inbounds for t in axes(nodes,1) - rate=rate_value(nodes[t,node],p) - p.rate[t,node]=rate - peak=max(peak,rate) + +clear_plasma!(::Nothing) = nothing +clear_plasma!(p) = foreach(a -> fill!(a, 0), (p.projected, p.edge_projected, p.coarse, p.coarse_edge)) + +function project_plasma!(p, c, first, last, quadrature) + count = last - first + 1 + for (values, full, coarse) in ((p.gated, p.projected, p.coarse), (p.edge, p.edge_projected, p.coarse_edge)) + block = @view values[:, 1:count] + mul!(full, block, @view(c.projection[first:last, :]), true, true) + quadrature && c.embedded && + mul!(coarse, block, @view(c.projection_coarse[first:last, :]), true, true) end - integrate_column!(p.fraction,p.rate,node,p) - peak end -# Observation scans read the accepted field afresh. They need rates and exposure, -# not the propagated current, Kerr/Raman response, projection or source FFTs. -function population_column!(p,nodes,node,first,parts) - nt=size(nodes,1) - peak=exposure_column!(p,nodes,node) - dip=rise=paid=early=maximum_integrand=0.0 - previous_exposure=0.0 - previous_product=0.0 - initial_fraction=0.0 - reach=2(length(p.taps)-1) - @inbounds for t in 1:nt - exposure=p.fraction[t,node] - if t > 1 - increment=exposure-previous_exposure - dip=max(dip,-increment) - rise=max(rise,increment) - end - previous_exposure=exposure - fraction=1-(1-p.parameters[9])*exp(-(p.floor ? max(exposure,0.0) : exposure)) - p.fraction[t,node]=fraction - product=p.rate[t,node]*(1-fraction) - if t == 1 - initial_fraction=fraction - else - # Keep this diagnostic trapezoid ordered and strict, like the prefix. - paid += p.dt*(product+previous_product)/2 - end - previous_product=product - integrand=abs(fraction*nodes[t,node]) - maximum_integrand=max(maximum_integrand,integrand) - if t <= reach - early=max(early,integrand) +"""Add `-i J / omega + edge / omega^2` of the projected currents to a spectrum.""" +function add_plasma!(destination, p, plan, c; coarse=false, direct=false) + mul!(p.spectrum, plan, direct ? p.gated : coarse ? p.coarse : p.projected) + mul!(p.edge_spectrum, plan, direct ? p.edge : coarse ? p.coarse_edge : p.edge_projected) + (; spectrum, edge_spectrum, inverse_omega) = p + crop, mask = c.crop, c.mask + each!(c, length(crop), size(destination, 2)) do f, m + @inbounds if mask[f] + k = crop[f] + inverse = inverse_omega[f] + destination[k, m] += -im * inverse * spectrum[k, m] + inverse^2 * edge_spectrum[k, m] end end - @inbounds begin - freed=p.fraction[nt,node]-initial_fraction - p.fractions[first+node-1]=p.fraction[nt,node] - p.peaks[first+node-1]=peak - parts[1,node]=dip - parts[2,node]=rise - parts[3,node]=abs(paid-freed) - parts[4,node]=freed - parts[5,node]=early - parts[6,node]=maximum_integrand - end - nothing end -function population_snapshot(engine,input) - engine.config.free && return population_free_snapshot(engine,input) - c,w=engine.config,engine.work - p=w.plasma - lab=Matrix{ComplexF64}(input) - fill!(w.fine,0) - foreach_sample(lab,c.tasks) do f,m,i - @inbounds w.fine[c.crop[f],m]=lab[i] - end - fft_apply!(w.modal,w.inverse_plan,w.fine,c) - chunk=size(w.nodes,2) - # Observation-only transient reductions are outside the owned march buffers. - parts=zeros(6,chunk) - maxima=zeros(6) - for first in 1:chunk:size(c.synthesis,2) - last=min(first+chunk-1,size(c.synthesis,2)) - count=last-first+1 - nodes=@view w.nodes[:,1:count] - mul!(nodes,w.modal,@view(c.synthesis[:,first:last])) - AK.foreachindex(1:count;max_tasks=c.tasks,min_elems=1) do node - population_column!(p,nodes,node,first,parts) + +"""Fresh accepted-field populations, for an observation: rates and exposure only.""" +function population_parts!(p, nodes, c, first, count) + T = typeof(p.dt) + (; rate, fraction, taps, dt, fractions, peaks, parts) = p + floor, args = p.floor, rate_arguments(p) + initial = T(p.parameters[9]) + nt, reach = size(nodes, 1), 2 * (length(taps) - 1) + each_column!(c, count) do node + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args) + dip = rise = paid = early = largest = zero(T) + before = product_before = start = zero(T) + @inbounds for t in 1:nt + exposure = fraction[t, node] + if t > 1 + dip = max(dip, before - exposure) + rise = max(rise, exposure - before) + end + before = exposure + value = 1 - (1 - initial) * exp(-(floor ? max(exposure, zero(T)) : exposure)) + fraction[t, node] = value + product = rate[t, node] * (1 - value) + if t == 1 + start = value + else + # The diagnostic's trapezoid is ordered and strict, like the prefix. + paid += dt * (product + product_before) / 2 + end + product_before = product + integrand = abs(value * nodes[t, node]) + largest = max(largest, integrand) + t <= reach && (early = max(early, integrand)) end - @inbounds for node in 1:count, i in 1:6 - maxima[i]=max(maxima[i],parts[i,node]) + @inbounds begin + freed = fraction[nt, node] - start + fractions[first+node-1] = fraction[nt, node] + peaks[first+node-1] = peak + parts[1, node], parts[2, node], parts[3, node] = dip, rise, abs(paid - freed) + parts[4, node], parts[5, node], parts[6, node] = freed, early, largest end + nothing end - (copy(p.fractions),copy(p.peaks),maxima) + vec(maximum(Array(parts)[:, 1:count]; dims=2, init=zero(T))) end -function raman_workspace(input,c,nt,chunk) - (haskey(input,"raman") && Bool(input["raman"])) || return nothing - rows=Matrix{Float64}(input["raman_undamped"]) - rates=Vector{Float64}(input["raman_rates"]) - dt=Float64(input["dt"]) - kernel=zeros(2nt,1) - for term in eachindex(rates), t in 1:2nt - @inbounds kernel[t] += rows[t,term]*exp(-rates[term]*(t-1)*dt) - end - kernel .*= Float64(input["raman_fraction"]) - plan=plan_rfft(fft_storage(kernel),1;flags=c.fft_flags,num_threads=1) - # MEASURE may overwrite its planning input. - fill!(kernel,0) +# --- Raman ---------------------------------------------------------------------------- + +function raman_workspace(c, host, nt, chunk) + host.flag("raman") || return nothing + T = c.T + rows, rates = host.array("raman_undamped", Float64), host.array("raman_rates", Float64) + dt = host.real("dt") + kernel = zeros(2nt) for term in eachindex(rates), t in 1:2nt - @inbounds kernel[t] += rows[t,term]*exp(-rates[term]*(t-1)*dt) + kernel[t] += rows[t, term] * exp(-rates[term] * (t - 1) * dt) end - kernel .*= Float64(input["raman_fraction"]) - spectrum=vec(plan*kernel).*dt - drive=zeros(2nt,chunk) - frequency=zeros(ComplexF64,nt+1,chunk) - (kernel=spectrum,factor=Float64(input["raman_factor"]),thg=Bool(input["raman_thg"]), - drive=drive,frequency=frequency,result=zeros(c.envelope ? ComplexF64 : Float64,nt,chunk), - forward=plan_rfft(fft_storage(drive),1;flags=c.fft_flags,num_threads=c.raman_fft_threads), - inverse=plan_irfft(fft_storage(frequency),2nt,1;flags=c.fft_flags,num_threads=c.raman_fft_threads)) + kernel .*= host.real("raman_fraction") + # The inverse transform is unnormalised: its 1/(2 nt) is folded into the kernel. + spectrum = FFTW.rfft(kernel) .* (dt / (2nt)) + drive = dzeros(c, T, 2nt, chunk) + frequency = dzeros(c, Complex{T}, nt + 1, chunk) + (kernel=upload(c, Complex{T}.(spectrum)), factor=host.real("raman_factor"), + thg=host.flag("raman_thg"), drive=drive, frequency=frequency, + forward=plan(c, plan_rfft, drive, 1; threads=c.raman_fft_threads), + inverse=plan(c, plan_brfft, frequency, 2nt, 1; threads=c.raman_fft_threads)) end -function raman_response!(r,nodes,analytic,c) - nt,count=size(nodes) - fill!(r.drive,0) - foreach_sample(nodes,c.tasks) do t,m,i - @inbounds r.drive[t,m]=r.thg ? abs2(nodes[i]) : 0.5*abs2(analytic[t,m]) - end - mul!(r.frequency,r.forward,r.drive) - foreach_sample(r.frequency,c.tasks) do f,m,i - @inbounds r.frequency[i] *= r.kernel[f] - end - fft_apply!(r.drive,r.inverse,r.frequency,c) - foreach_sample(nodes,c.tasks) do t,m,i - @inbounds r.result[t,m]=r.factor*nodes[i]*r.drive[t,m] + +"""Convolve each node's drive, `|E|^2` (or half the analytic signal's), with the kernel.""" +function raman_drive!(r, nodes, analytic, c, count) + nt = size(nodes, 1) + (; drive, frequency, kernel) = r + thg = r.thg + each!(c, 2nt, size(drive, 2)) do t, m + @inbounds drive[t, m] = t > nt || m > count ? zero(eltype(drive)) : + thg ? abs2(nodes[t, m]) : abs2(analytic[t, m]) / 2 end -end -function add_raman!(r,nodes,c) - foreach_sample(nodes,c.tasks) do t,m,i - @inbounds nodes[i] += r.result[t,m]*c.window[t] + mul!(frequency, r.forward, drive) + each!(c, nt + 1, size(drive, 2)) do f, m + @inbounds frequency[f, m] *= kernel[f] end + mul!(drive, r.inverse, frequency) + nothing end diff --git a/julia/src/rk4.jl b/julia/src/rk4.jl index 725247dfd..b91c37464 100644 --- a/julia/src/rk4.jl +++ b/julia/src/rk4.jl @@ -1,56 +1,58 @@ # SPDX-FileCopyrightText: 2026 John C. Travers and contributors # SPDX-License-Identifier: GPL-3.0-or-later -# The four register passes of the existing SEP 24 scheme. A constant flow's key -# is the schedule run's mean step, supplied by the shared table_steps policy. -function masked_squared(engine,a) - c,w=engine.config,engine.work - AK.foreachindex(axes(a,2);max_tasks=c.tasks,min_elems=1) do m - value=0.0 - @inbounds for f in axes(a,1) - if c.norm_mask[f] - value += abs2(a[f,m]) - end +# The four register passes of SEP 24's RK4IP. A constant flow's key is the schedule +# run's mean step, from the shared table_steps policy. Each pass also forms the norms +# the march reads: the state's, and the stiffness estimate's two slope differences. + +function rk4!(engine, dz::Float64, key::Float64) + c, w = engine.config, engine.work + T = real_type(engine) + (; y, lab, candidate, error, source, forward) = w + mask = c.norm_mask + h, half, third, sixth = T(dz), T(dz / 2), T(dz / 3), T(dz / 6) + free_propagators!(engine, key / 2) + source!(engine, y) + each!(c, size(y)...) do f, m + @inbounds begin + flow = forward[f, m, 1] + y[f, m] *= flow + slope = flow * source[f, m] + error[f, m] = slope + candidate[f, m] = y[f, m] + sixth * slope + lab[f, m] = y[f, m] + half * slope end - w.partials[1,m]=value end - sum(@view w.partials[1,:]) -end -function rk4!(engine,dz::Float64,key::Float64) - c,w=engine.config,engine.work - free_propagators!(engine,key/2) - source!(engine,w.y) - foreach_sample(w.y,c.tasks) do f,m,i + source!(engine, lab) + lower = reduce_each(+, zero(T), c, size(y)...) do f, m @inbounds begin - w.y[i] *= w.forward[i] - slope=w.forward[i]*w.source[i] - w.error[i]=slope - w.candidate[i]=w.y[i]+(dz/6)*slope - w.lab[i]=w.y[i]+(dz/2)*slope + slope = source[f, m] + difference = slope - error[f, m] + # The second slope is the third's reference: kept where the first was. + error[f, m] = slope + candidate[f, m] += third * slope + lab[f, m] = y[f, m] + half * slope + mask[f] ? abs2(difference) : zero(T) end end - source!(engine,w.lab) - foreach_sample(w.y,c.tasks) do f,m,i + source!(engine, lab) + upper = reduce_each(+, zero(T), c, size(y)...) do f, m @inbounds begin - w.error[i]=w.source[i]-w.error[i] - w.candidate[i] += (dz/3)*w.source[i] - w.lab[i]=w.y[i]+(dz/2)*w.source[i] + slope = source[f, m] + difference = slope - error[f, m] + error[f, m] = difference + candidate[f, m] += third * slope + lab[f, m] = forward[f, m, 1] * (y[f, m] + h * slope) + mask[f] ? abs2(difference) : zero(T) end end - lower=masked_squared(engine,w.error) - copy_volume!(w.error,w.source,c) - source!(engine,w.lab) - foreach_sample(w.y,c.tasks) do f,m,i + source!(engine, lab) + squared = reduce_each(+, zero(T), c, size(y)...) do f, m @inbounds begin - w.error[i]=w.source[i]-w.error[i] - w.candidate[i] += (dz/3)*w.source[i] - w.lab[i]=w.forward[i]*(w.y[i]+dz*w.source[i]) + new = forward[f, m, 1] * candidate[f, m] + sixth * source[f, m] + candidate[f, m] = new + mask[f] ? abs2(new) : zero(T) end end - upper=masked_squared(engine,w.error) - source!(engine,w.lab) - foreach_sample(w.y,c.tasks) do f,m,i - @inbounds w.candidate[i]=w.forward[i]*w.candidate[i]+(dz/6)*w.source[i] - end - (masked_squared(engine,w.candidate),lower > 0 ? 2sqrt(upper/lower) : NaN) + (Float64(squared), lower > 0 ? 2sqrt(Float64(upper) / Float64(lower)) : NaN) end diff --git a/julia/src/stages.jl b/julia/src/stages.jl index 5a121a049..ea0c2f566 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -1,50 +1,67 @@ # SPDX-FileCopyrightText: 2026 John C. Travers and contributors # SPDX-License-Identifier: GPL-3.0-or-later -# The translation layer owns the expansion and its scalar evaluation. No pressure -# law or material formula crosses this boundary: only fixed arrays and weights. -function path_workspace(input,c) - haskey(input,"phi_terms") || return nothing - phi=Array{ComplexF64,3}(input["phi_terms"]) - pre=Array{ComplexF64,3}(input["prefactor_terms"]) - (phi=phi,prefactor=pre,delta=zeros(size(phi,3),length(c.c)), - weights=zeros(size(pre,3),length(c.c)),material=zeros(3,length(c.c))) +# Longitudinal expansions. The translation owns the expansion and its scalar +# evaluation: only fixed term arrays and each stage's weights cross, never a pressure +# law or a material formula. + +function path_workspace(c, host) + host.has("phi_terms") || return nothing + C = Complex{c.T} + phi, pre = host.array("phi_terms", C), host.array("prefactor_terms", C) + stages = 7 + (phi=upload(c, phi), prefactor=upload(c, pre), + delta=zeros(size(phi, 3), stages), weights=zeros(size(pre, 3), stages), + delta_device=dzeros(c, c.T, size(phi, 3), stages), + weights_device=dzeros(c, c.T, size(pre, 3), stages), material=zeros(3, stages)) end -function configure_stages!(engine,delta,weights,material) - p=engine.work.path - copyto!(p.delta,Matrix{Float64}(delta)) - copyto!(p.weights,Matrix{Float64}(weights)) - copyto!(p.material,Matrix{Float64}(material)) - material_stage!(engine,1) + +"""Take a trial's stage weights: Phi increments, prefactor weights and material scales.""" +function configure_stages!(engine, delta, weights, material) + p = engine.work.path + copyto!(p.delta, Matrix{Float64}(delta)) + copyto!(p.weights, Matrix{Float64}(weights)) + copyto!(p.material, Matrix{Float64}(material)) + copyto!(p.delta_device, real_type(engine).(p.delta)) + copyto!(p.weights_device, real_type(engine).(p.weights)) + material_stage!(engine, 1) nothing end -function material_stage!(engine,stage) - c,w=engine.config,engine.work - p=w.path - foreach_sample(c.prefactor,c.tasks) do f,m,i - value=0.0im - @inbounds for term in axes(p.prefactor,3) - value += p.prefactor[f,m,term]*p.weights[term,stage] + +"""Make a stage's prefactor, Kerr factor and plasma density current.""" +function material_stage!(engine, stage) + c, w = engine.config, engine.work + p = w.path + (; prefactor) = c + terms, weights = p.prefactor, p.weights_device + each!(c, size(prefactor)...) do f, m + value = zero(eltype(prefactor)) + @inbounds for term in axes(terms, 3) + value += terms[f, m, term] * weights[term, stage] end - @inbounds c.prefactor[i]=value + @inbounds prefactor[f, m] = value end - engine.factor=p.material[1,stage] - if !isnothing(w.plasma) - w.plasma.parameters[8]=p.material[2,stage] - w.plasma.parameters[9]=p.material[3,stage] + engine.factor = p.material[1, stage] + if w.plasma !== nothing + w.plasma.parameters[8] = p.material[2, stage] + w.plasma.parameters[9] = p.material[3, stage] end end + +"""Every stage's propagator pair from the expansion: `exp(+-sum_k phi_k delta_k)`.""" function path_propagators!(engine) - c,w=engine.config,engine.work - p=w.path - foreach_sample(w.y,c.tasks) do f,m,i - @inbounds for stage in eachindex(c.c) - exponent=0.0im - for term in axes(p.phi,3) - exponent += p.phi[f,m,term]*p.delta[term,stage] + c, w = engine.config, engine.work + p = w.path + (; forward, inverse) = w + phi, delta = p.phi, p.delta_device + each!(c, size(w.y)...) do f, m + @inbounds for stage in 1:7 + exponent = zero(eltype(phi)) + for term in axes(phi, 3) + exponent += phi[f, m, term] * delta[term, stage] end - w.forward[f,m,stage]=exp(exponent) - w.inverse[f,m,stage]=exp(-exponent) + forward[f, m, stage] = exp(exponent) + inverse[f, m, stage] = exp(-exponent) end end end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index b25277a6c..3d3933e75 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -6,6 +6,7 @@ import dataclasses import logging import math +import os from collections.abc import Mapping, Sequence from typing import Literal @@ -314,6 +315,7 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: "transverse_fft_threads": fft_threads, "blas_threads": thread_limit("SOLPROP_JULIA_BLAS_THREADS", blas_default), "chunk": transform.node_chunk, + "device": os.environ.get("SOLPROP_JULIA_DEVICE", "cpu"), } if _varying(problem): @@ -447,7 +449,7 @@ def __init__( self._varying = _varying(problem) if self._varying: self._prepare_stages(0.0, 0.0) - self._plan_flag = str(getattr(self._engine.config, "plan_flag", "estimate")) + self._plan_flag = os.environ.get("SOLPROP_FFTW_PLAN") or "native policy" self._weight = ( np.empty(0) if problem.transform.geometry is not None From 5f64f1a5961f7410bf2f478fd1b6b8bb5d068340 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 14:22:06 +0000 Subject: [PATCH 004/107] Julia: one CPU pool, measured plans, modal-product Raman [skip ci] Every CPU pass, transform and product runs in Polyester's pool: FFTs are blocks of whole columns (or plane rows) with one single-threaded plan each, GEMMs blocks of rows of single-threaded BLAS. FFTW and BLAS threads beside the pool's spinning workers made 4-thread runs slower than one. Every plan is measured (a threaded estimate of the Raman c2r was 4.4x slower). Raman convolves the modal products once a source when there are fewer than nodes, as native does: H2 Raman 25 s -> 3.7 s on four cores. Heavy passes (the Adams phi functions) split at a smaller size, and skip out-of-band bins, where everything is exactly zero. Co-Authored-By: Claude Opus 5.5 --- julia/Manifest.toml | 172 ++++++++++++++++++++++++- julia/Project.toml | 2 + julia/profile.py | 18 ++- julia/src/SolpropJulia.jl | 9 +- julia/src/adams.jl | 16 ++- julia/src/dopri.jl | 6 +- julia/src/free.jl | 4 +- julia/src/launch.jl | 119 +++++++++++++---- julia/src/modal.jl | 41 +++--- julia/src/responses.jl | 86 ++++++++++--- src/solprop/backends/julia/_backend.py | 18 +-- 11 files changed, 404 insertions(+), 87 deletions(-) diff --git a/julia/Manifest.toml b/julia/Manifest.toml index cf1eae287..628851217 100644 --- a/julia/Manifest.toml +++ b/julia/Manifest.toml @@ -2,7 +2,7 @@ julia_version = "1.13.3" manifest_format = "2.1" -project_hash = "47a61e1134d91d5abf69dc007c90be5b71a4f8fb" +project_hash = "fa29c7ab8044951428f5c6a1cb0f867920a4aac6" [[deps.AbstractFFTs]] deps = ["LinearAlgebra"] @@ -64,6 +64,46 @@ version = "2.5.0" uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" version = "1.1.2" +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + [[deps.Artifacts]] uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" version = "1.11.0" @@ -83,12 +123,51 @@ version = "1.7.0" uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" version = "1.11.0" +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + [[deps.CEnum]] git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" registries = "General" uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" version = "0.5.0" +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + [[deps.CompilerCaching]] deps = ["LMDB", "SHA", "Scratch"] git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" @@ -108,6 +187,13 @@ registries = "General" uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" version = "0.2.38" +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + [[deps.DataAPI]] git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" registries = "General" @@ -200,6 +286,12 @@ registries = "General" uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" version = "2.15.0+0" +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + [[deps.IntelOpenMP_jll]] deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" @@ -315,6 +407,13 @@ registries = "General" uuid = "6206cf0b-f360-5984-af49-5437264c140e" version = "1.0.3+0" +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + [[deps.LazyArtifacts]] deps = ["Artifacts", "Pkg"] uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" @@ -385,6 +484,12 @@ registries = "General" uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" version = "0.5.16" +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + [[deps.Markdown]] deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" @@ -442,6 +547,20 @@ weakdeps = ["REPL"] [deps.Pkg.extensions] REPLExt = "REPL" +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + [[deps.PrecompileTools]] deps = ["Preferences"] git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" @@ -510,6 +629,12 @@ version = "1.2.2" uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" version = "1.0.0" +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + [[deps.SLEEF_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" @@ -548,6 +673,13 @@ registries = "General" uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" version = "2025.4.0+0" +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + [[deps.ScopedValues]] deps = ["HashArrayMappedTries", "Logging"] git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" @@ -571,17 +703,46 @@ uuid = "6462fe0b-24de-5631-8697-dd941f90decc" version = "1.11.0" [[deps.SolpropJulia]] -deps = ["AcceleratedKernels", "FFTW", "KernelAbstractions", "LinearAlgebra", "PythonCall"] +deps = ["AcceleratedKernels", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] path = "." uuid = "bc9db228-6fd1-46b1-b175-748485922872" version = "0.0.0" +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + [[deps.StaticArraysCore]] git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" registries = "General" uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" version = "1.4.4" +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + [[deps.StructUtils]] deps = ["Dates", "UUIDs"] git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" @@ -633,6 +794,13 @@ deps = ["ArgTools", "SHA"] uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" version = "1.10.0" +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + [[deps.Tracy]] deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" diff --git a/julia/Project.toml b/julia/Project.toml index d16dfc01f..ecd2a82a3 100644 --- a/julia/Project.toml +++ b/julia/Project.toml @@ -6,7 +6,9 @@ AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" [compat] +Polyester = "0.7.19" julia = "1.13" diff --git a/julia/profile.py b/julia/profile.py index 7abf9421b..db64d672b 100644 --- a/julia/profile.py +++ b/julia/profile.py @@ -6,8 +6,9 @@ ``python julia/profile.py PLAN.json ROW [FRACTION]`` builds the row's case for the julia backend, warms it up, then samples Julia's stacks over a propagation to ``FRACTION`` of the row's stop (default 1) and prints the flat profile. Run it with -``SOLPROP_JULIA_THREADS=1``: Julia's sampling profiler is unreliable when Python -owns the threads. +``SOLPROP_JULIA_THREADS=1``: Julia's sampling profiler crashes when Python owns more +threads. ``SOLPROP_JULIA_TIMING=1`` prints the engine's section timers instead, at +any width. """ import json @@ -37,6 +38,19 @@ def main() -> None: engine.set_initial(problem.initial.field0, None, z=problem.initial.z) engine.propagate_to(0.5 * stop) from juliacall import Main as jl # noqa: PLC0415 - after the runtime starts + + timing = bool(engine._jl.timing_enabled()) # noqa: SLF001 + if timing: + engine._jl.clear_timings() # noqa: SLF001 + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + started = time.perf_counter() + engine.propagate_to(stop) + seconds = time.perf_counter() - started + times = engine._jl.timings() # noqa: SLF001 + for name in sorted(times, key=lambda n: -float(times[n])): + sys.stdout.write(f"{name:>20} {float(times[name]):9.4f} s\n") + sys.stdout.write(f"{row['id']}: {seconds:.3f} s to {stop:.3g} m\n") + return jl.seval("using Profile; Profile.init(n=10^7, delay=0.0005)") engine.set_initial(problem.initial.field0, None, z=problem.initial.z) jl.seval("Profile.clear(); Profile.start_timer()") diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index f169bca67..d29c2f4cc 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -15,6 +15,7 @@ module SolpropJulia using LinearAlgebra using FFTW using PythonCall +using Polyester: @batch import AcceleratedKernels as AK import KernelAbstractions as KA @@ -43,13 +44,17 @@ include("stages.jl") real_type(engine) = real(eltype(engine.work.y)) +# Read at load, not at precompilation: a constant would be baked into the cache. +__init__() = (TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "1"; nothing) + """Read the shared settings and route to the modal or the free-space engine.""" function create(input) host = HostInput(input) T = host.has("precision") && host.string("precision") == "single" ? Float32 : Float64 backend = device_backend(Val(Symbol(host.has("device") ? host.string("device") : "cpu"))) - FFTW.set_num_threads(host.int("fft_threads")) - BLAS.set_num_threads(host.int("blas_threads")) + # One pool runs everything (launch.jl, `plan`): the libraries' own are single. + FFTW.set_num_threads(1) + BLAS.set_num_threads(1) c = ( backend=backend, T=T, tasks=host.int("threads"), fft_threads=host.int("fft_threads"), diff --git a/julia/src/adams.jl b/julia/src/adams.jl index d174b88d6..ef8e68544 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -144,8 +144,16 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} step = Float64(h) mask = c.norm_mask # The predictor, the flow and its moments, and the state's norm for the scale. - squared = reduce_each(+, zero(T), c, size(y)...) do f, m + active = c.mask + squared = @section :adams_predict reduce_each(+, zero(T), c, size(y)...; heavy=true) do f, m @inbounds begin + # Outside the band the state, the history and the source are exactly zero, + # and so is everything this element forms. + if !active[f] + lab[f, m] = 0 + compensated && (endpoint[f, m] = 0; error[f, m] = 0) + return zero(T) + end x = ComplexF64(step * linear[f, m]) if phi !== nothing x = zero(ComplexF64) @@ -189,8 +197,12 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} magnitude = sqrt(squared) relative, absolute, weight = T(c.rtol) * magnitude, T(c.atol), c.weights zero3 = (zero(T), zero(T), zero(T)) - norms = reduce_each(.+, zero3, c, size(y)...) do f, m + norms = @section :adams_correct reduce_each(.+, zero3, c, size(y)...; heavy=true) do f, m @inbounds begin + if !active[f] + candidate[f, m] = 0 + return zero3 + end corrected = zero(C) for k in 1:N weighted = corrector[1, k] * source[f, m] diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 2e0e38174..ffca720df 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -36,7 +36,7 @@ function trial!(engine, dz::Float64) c, w = engine.config, engine.work T = real_type(engine) (; y, lab, stages, forward, inverse, source) = w - propagators!(engine, dz) + @section :propagators propagators!(engine, dz) for stage in 1:7 stage == 1 && engine.fsal_valid && continue w.path !== nothing && material_stage!(engine, stage) @@ -59,13 +59,13 @@ function trial!(engine, dz::Float64) lab[f, m] = forward[f, m, slot] * (y[f, m] + combination) end end - source!(engine, lab; quadrature=stage == 7) + @section :source source!(engine, lab; quadrature=stage == 7) each!(c, size(y)...) do f, m @inbounds stages[f, m, stage] = inverse[f, m, slot] * source[f, m] end end engine.fsal_valid = true - combine!(engine, dz, c.free ? 1 : 7) + @section :combine combine!(engine, dz, c.free ? 1 : 7) end """The candidate and the error estimate, and the controller's norm of the error. diff --git a/julia/src/free.jl b/julia/src/free.jl index ec6bf07ee..78e896745 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -41,7 +41,7 @@ function create_free(c, host) fine, modal = dzeros(c, C, nf, chunk), dzeros(c, R, nt, chunk) analytic = dzeros(c, C, nt, chunk) coarse, coarse_spec = dzeros(c, R, nc, chunk), dzeros(c, C, nw, chunk) - planes = (threads=c.transverse_fft_threads, shape=:planes) + planes = (threads=c.transverse_fft_threads, batch=1) work = ( adams=nothing, path=nothing, raman=nothing, plasma=plasma_workspace(c, host, nt, chunk, chunk, nm), @@ -167,7 +167,7 @@ function source_free!(engine, lab) each!(c, size(modal)...) do t, m @inbounds projected[t, m] = scale * modal[t, m] end - analytic_signal!(analytic, projected, w, c, chunk) + analytic_signal!(analytic, projected, w.analytic_forward, w.analytic_inverse, c, chunk) nonlinear_nodes!(projected, analytic, c, factor, nothing, chunk) else each!(c, size(modal)...) do t, m diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 898c609ee..d44573a53 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -32,20 +32,23 @@ const PARALLEL_SAMPLES = 65536 On a CPU each task takes whole columns, or pieces of one when there are fewer columns than tasks, and runs a contiguous `@simd` loop over its rows: an index divide per -sample costs a factor of ten (julia/bench/launch.jl). On a GPU each sample is a thread. +sample costs a factor of ten (julia/bench/launch.jl). The tasks are Polyester's, +whose threads wait spinning: a pass between serial work costs 2.2 us on four Xeon +cores where a spawned task costs 10 and `Threads.@threads` 110 (10240 x 4; 13, 49 and +147 us over 1728 x 128). On a GPU each sample is a thread. """ -@inline each!(f::F, c, nt::Integer, nm::Integer) where {F} = - each_on!(f, c.backend, c.tasks, Int(nt), Int(nm)) +@inline each!(f::F, c, nt::Integer, nm::Integer; heavy=false) where {F} = + each_on!(f, c.backend, c.tasks, Int(nt), Int(nm), heavy) -function each_on!(f::F, ::KA.CPU, tasks, nt, nm) where {F} - pieces, rows = tiling(tasks, nt, nm) +function each_on!(f::F, ::KA.CPU, tasks, nt, nm, heavy) where {F} + pieces, rows = tiling(tasks, nt, nm, heavy) if pieces * nm == 1 @inbounds @simd for t in 1:nt @inline f(t, 1) end return nothing end - AK.foreachindex(1:pieces*nm; max_tasks=tasks, min_elems=1) do k + @batch for k in 1:pieces*nm m = (k - 1) ÷ pieces + 1 first = (k - (m - 1) * pieces - 1) * rows + 1 @inbounds @simd for t in first:min(first + rows - 1, nt) @@ -55,13 +58,18 @@ function each_on!(f::F, ::KA.CPU, tasks, nt, nm) where {F} nothing end -"""Split `nt` x `nm` samples into column pieces: one task's worth each.""" -function tiling(tasks, nt, nm) - if tasks == 1 || nt * nm < PARALLEL_SAMPLES +"""Split `nt` x `nm` samples into column pieces: one task's worth each. + +A `heavy` body (tens of operations a sample, such as the phi functions) is worth +splitting at a thirty-second of the samples a light one needs. +""" +function tiling(tasks, nt, nm, heavy=false) + least = heavy ? PARALLEL_SAMPLES ÷ 32 : PARALLEL_SAMPLES + if tasks == 1 || nt * nm < least return 1, nt end nm >= tasks && return 1, nt - pieces = min(cld(tasks, nm), cld(nt * nm, PARALLEL_SAMPLES ÷ 4)) + pieces = min(cld(tasks, nm), cld(nt * nm, least ÷ 4)) pieces, cld(nt, pieces) end @@ -69,7 +77,7 @@ KA.@kernel inbounds = true function each_kernel!(f) t, m = KA.@index(Global, NTuple) f(t, m) end -function each_on!(f::F, backend, tasks, nt, nm) where {F} +function each_on!(f::F, backend, tasks, nt, nm, heavy) where {F} each_kernel!(backend, (256, 1))(f; ndrange=(nt, nm)) nothing end @@ -77,7 +85,7 @@ end """Call `f(m)` for each of `nm` columns, whose body runs sequentially down one.""" function each_column!(f::F, c, nm::Integer) where {F} if oncpu(c) - AK.foreachindex(1:Int(nm); max_tasks=c.tasks, min_elems=1) do m + @batch for m in 1:Int(nm) @inline f(m) end else @@ -91,12 +99,12 @@ end `op` must be associative and commutative: the order is the tiling's (CPU) or the reduction tree's (GPU), and differs with the width (SEP 25 bounds it, not bits). """ -function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer) where {F,O} +function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=false) where {F,O} nt, nm = Int(nt), Int(nm) if oncpu(c) - pieces, rows = tiling(c.tasks, nt, nm) + pieces, rows = tiling(c.tasks, nt, nm, heavy) partials = fill(neutral, pieces * nm) - AK.foreachindex(1:pieces*nm; max_tasks=c.tasks, min_elems=1) do k + @batch for k in 1:pieces*nm m = (k - 1) ÷ pieces + 1 first = (k - (m - 1) * pieces - 1) * rows + 1 value = neutral @@ -113,22 +121,85 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer) where {F end end -# FFTW's planner: native's policy (native/include/solprop_native/fft_plan.hpp). Serial -# row transforms and every transverse plane are measured, threaded rows estimated (a -# measured threaded plan was slower there); SOLPROP_FFTW_PLAN overrides all of them. +# FFTW's planner measures every plan unless SOLPROP_FFTW_PLAN says otherwise. Unlike +# native's policy (rows estimated when threaded), a threaded estimate is far slower +# here: the Raman convolution's c2r of 73728 x 17 takes 6.6 ms estimated and 1.49 ms +# measured on four Xeon cores, 7.5 and 4.9 ms on one (planning is at construction). const FLAGS = Dict("estimate" => FFTW.ESTIMATE, "measure" => FFTW.MEASURE, "patient" => FFTW.PATIENT) -function plan_flags(shape::Symbol, threads) +function plan_flags() chosen = get(ENV, "SOLPROP_FFTW_PLAN", "") - isempty(chosen) && return shape === :rows && threads > 1 ? FFTW.ESTIMATE : FFTW.MEASURE + isempty(chosen) && return FFTW.MEASURE haskey(FLAGS, chosen) || throw(ArgumentError("SOLPROP_FFTW_PLAN must be estimate, measure or patient")) FLAGS[chosen] end """Plan `kind(a, args...)` for the engine's device; inverses are left unnormalised. -On a CPU, measuring overwrites `a`: plan before anything is stored in it. +On a CPU with several tasks the transform is split into blocks of whole batches along +dimension `batch` (columns for row transforms, rows for transverse planes), one +single-threaded plan each, run by the pool that runs every other pass: FFTW's and +BLAS's own threads beside Polyester's spinning ones made a four-thread rdw run seven +times slower than one thread. Measuring overwrites `a`: plan before storing in it. """ -plan(c, kind, a, args...; threads=c.fft_threads, shape=:rows) = - oncpu(c) ? kind(a, args...; flags=plan_flags(shape, threads), num_threads=threads) : - kind(a, args...) +function plan(c, kind, a, args...; threads=c.fft_threads, batch=2) + oncpu(c) || return kind(a, args...) + blocks = min(threads, size(a, batch)) + blocks <= 1 && return kind(a, args...; flags=plan_flags(), num_threads=1) + ranges = [r for r in Iterators.partition(axes(a, batch), cld(size(a, batch), blocks))] + # A block's view starts anywhere in the array: its plan may not assume alignment. + plans = [kind(block_view(a, batch, r), args...; flags=plan_flags() | FFTW.UNALIGNED, + num_threads=1) for r in ranges] + Blocked(plans, ranges, batch) +end + +struct Blocked{P} + plans::Vector{P} + ranges::Vector{UnitRange{Int}} + batch::Int +end +block_view(a, batch, r) = batch == 2 ? view(a, :, r) : view(a, r, ntuple(_ -> Colon(), ndims(a) - 1)...) +function LinearAlgebra.mul!(y, p::Blocked, x) + @batch for b in eachindex(p.plans) + mul!(block_view(y, p.batch, p.ranges[b]), p.plans[b], block_view(x, p.batch, p.ranges[b])) + end + y +end +function Base.:*(p::Blocked, x) + @batch for b in eachindex(p.plans) + p.plans[b] * block_view(x, p.batch, p.ranges[b]) + end + x +end + +"""`C = alpha A B + beta C`: on a CPU, blocks of rows of `C` and `A` as the pool's tasks.""" +function gemm!(C, A, B, alpha, beta, c) + blocks = oncpu(c) ? min(c.tasks, cld(length(C), PARALLEL_SAMPLES ÷ 4)) : 1 + blocks <= 1 && return mul!(C, A, B, alpha, beta) + rows = cld(size(C, 1), blocks) + @batch for b in 1:blocks + r = (b-1)*rows+1:min(b * rows, size(C, 1)) + mul!(view(C, r, :), view(A, r, :), B, alpha, beta) + end + C +end + +# Section timers for development: SOLPROP_JULIA_TIMING=1 when the module loads. Off, +# `@section` is its expression alone. On a GPU the times are launch times only. +const TIMING = Ref(false) +const TIMES = Dict{Symbol,Float64}() +macro section(name, ex) + quote + if TIMING[] + local started = time_ns() + local result = $(esc(ex)) + TIMES[$name] = get(TIMES, $name, 0.0) + (time_ns() - started) * 1e-9 + result + else + $(esc(ex)) + end + end +end +timings() = Dict(String(k) => v for (k, v) in TIMES) +clear_timings() = (empty!(TIMES); nothing) +timing_enabled() = TIMING[] diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 7afeea702..b9b9de22e 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -58,7 +58,7 @@ function create_modal(c, host) band = dzeros(c, C, nw, nm) work = ( adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), - raman=raman_workspace(c, host, nt, chunk), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), + raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), stages=dzeros(c, C, nw, nm, ns), forward=dzeros(c, C, nw, nm, ns), inverse=dzeros(c, C, nw, nm, ns), @@ -90,36 +90,39 @@ function source!(engine, lab; quadrature=false) c, w = engine.config, engine.work c.free && return source_free!(engine, lab) nm = size(lab, 2) - scatter!(w.fine, lab, c) - mul!(w.modal, w.inverse_plan, w.fine) + @section :scatter scatter!(w.fine, lab, c) + @section :inverse_fft mul!(w.modal, w.inverse_plan, w.fine) fill!(w.projected, 0) quadrature && fill!(w.projected_coarse, 0) clear_plasma!(w.plasma) if engine.factor != 0 || w.plasma !== nothing || w.raman !== nothing + products = w.raman !== nothing && w.raman.products + products && @section :raman raman_products!(w.raman, w.modal, c) chunk, nn = size(w.nodes, 2), size(c.synthesis, 2) for first in 1:chunk:nn last = min(first + chunk - 1, nn) count = last - first + 1 nodes = @view w.nodes[:, 1:count] - mul!(nodes, w.modal, @view(c.synthesis[:, first:last])) + @section :synthesis gemm!(nodes, w.modal, @view(c.synthesis[:, first:last]), true, false, c) if w.plasma !== nothing - plasma_current!(w.plasma, w.nodes, c, count) - project_plasma!(w.plasma, c, first, last, quadrature) + @section :plasma plasma_current!(w.plasma, w.nodes, c, count) + @section :plasma_projection project_plasma!(w.plasma, c, first, last, quadrature) end + products && @section :raman raman_nodal!(w.raman, first, last, c) node_response!(engine, count) - mul!(w.projected, nodes, @view(c.projection[first:last, :]), true, true) + @section :projection gemm!(w.projected, nodes, @view(c.projection[first:last, :]), true, true, c) quadrature && c.embedded && - mul!(w.projected_coarse, nodes, @view(c.projection_coarse[first:last, :]), true, true) + gemm!(w.projected_coarse, nodes, @view(c.projection_coarse[first:last, :]), true, true, c) end end - mul!(w.fine, w.forward_plan, w.projected) - w.plasma === nothing || add_plasma!(w.fine, w.plasma, w.forward_plan, c) + @section :forward_fft mul!(w.fine, w.forward_plan, w.projected) + w.plasma === nothing || @section :plasma_spectrum add_plasma!(w.fine, w.plasma, w.forward_plan, c) if c.in_stage absorber!(w.absorber, w.modal, c) - isempty(c.spatial_absorber) || mul!(w.absorber, w.modal, c.spatial_absorber, true, true) + isempty(c.spatial_absorber) || gemm!(w.absorber, w.modal, c.spatial_absorber, true, true, c) mul!(w.absorber_spec, w.forward_plan, w.absorber) end - finish_source!(w.source, w.fine, c.in_stage ? w.absorber_spec : nothing, c) + @section :finish finish_source!(w.source, w.fine, c.in_stage ? w.absorber_spec : nothing, c) engine.calls += 1 nothing end @@ -131,13 +134,13 @@ function node_response!(engine, count) if c.envelope raman === nothing || raman_drive!(raman, nodes, nodes, c, count) nonlinear_envelope!(nodes, c, engine.factor, raman, count) - elseif c.analytic || (raman !== nothing && !raman.thg) - analytic_signal!(w.analytic, nodes, w, c, count) - raman === nothing || raman_drive!(raman, nodes, w.analytic, c, count) - nonlinear_nodes!(nodes, c.analytic ? w.analytic : nodes, c, engine.factor, raman, count) + elseif c.analytic || (raman !== nothing && !raman.thg && !raman.products) + @section :analytic analytic_signal!(w.analytic, nodes, w.analytic_forward, w.analytic_inverse, c, count) + raman === nothing || raman.products || @section :raman raman_drive!(raman, nodes, w.analytic, c, count) + @section :kerr nonlinear_nodes!(nodes, c.analytic ? w.analytic : nodes, c, engine.factor, raman, count) else - raman === nothing || raman_drive!(raman, nodes, nodes, c, count) - nonlinear_nodes!(nodes, nodes, c, engine.factor, raman, count) + raman === nothing || raman.products || @section :raman raman_drive!(raman, nodes, nodes, c, count) + @section :kerr nonlinear_nodes!(nodes, nodes, c, engine.factor, raman, count) end end @@ -182,7 +185,7 @@ function population_snapshot(engine, input) for first in 1:chunk:nn last = min(first + chunk - 1, nn) count = last - first + 1 - mul!(@view(w.nodes[:, 1:count]), w.modal, @view(c.synthesis[:, first:last])) + gemm!(@view(w.nodes[:, 1:count]), w.modal, @view(c.synthesis[:, first:last]), true, false, c) maxima .= max.(maxima, population_parts!(p, w.nodes, c, first, count)) end (Vector{Float64}(Array(p.fractions)), Vector{Float64}(Array(p.peaks)), maxima) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index bb87f91a2..9bd4190e9 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -22,7 +22,7 @@ function nonlinear_nodes!(nodes, values, c, factor, raman, count) @inbounds nodes[t, m] = polarization(values[t, m], f, a) * window[t] end else - drive, r = raman.drive, T(raman.factor) + drive, r = raman.products ? raman.nodal : raman.drive, T(raman.factor) each!(c, size(nodes, 1), count) do t, m @inbounds begin v = nodes[t, m] @@ -52,19 +52,19 @@ function nonlinear_envelope!(nodes, c, factor, raman, count) end """Replace `analytic` by the analytic signal of the real columns of `nodes`.""" -function analytic_signal!(analytic, nodes, w, c, count) +function analytic_signal!(analytic, nodes, forward, inverse, c, count) nt, chunk = size(analytic) each!(c, nt, chunk) do t, m @inbounds analytic[t, m] = m <= count ? nodes[t, m] : 0 end - w.analytic_forward * analytic + forward * analytic # The unnormalised inverse's 1/nt is folded into the one-sided spectral factor. T = real(eltype(analytic)) one, two, half = inv(T(nt)), 2 / T(nt), nt ÷ 2 each!(c, nt, chunk) do f, m @inbounds analytic[f, m] *= (f == 1 || f == half + 1) ? one : f <= half ? two : zero(T) end - w.analytic_inverse * analytic + inverse * analytic nothing end @@ -241,9 +241,9 @@ function project_plasma!(p, c, first, last, quadrature) count = last - first + 1 for (values, full, coarse) in ((p.gated, p.projected, p.coarse), (p.edge, p.edge_projected, p.coarse_edge)) block = @view values[:, 1:count] - mul!(full, block, @view(c.projection[first:last, :]), true, true) + gemm!(full, block, @view(c.projection[first:last, :]), true, true, c) quadrature && c.embedded && - mul!(coarse, block, @view(c.projection_coarse[first:last, :]), true, true) + gemm!(coarse, block, @view(c.projection_coarse[first:last, :]), true, true, c) end end @@ -308,9 +308,16 @@ end # --- Raman ---------------------------------------------------------------------------- -function raman_workspace(c, host, nt, chunk) +"""The Raman workspace: the kernel's spectrum and the drives' transforms. + +With fewer of the M (M + 1) / 2 modal products than nodes, each product of the modes' +time signals is convolved once and a node's convolved drive is their sum weighted by +its synthesis (native's ``raman_modal_products``): the convolution is linear, so this +agrees with convolving the node's own drive to the rounding of the drive's scale. +""" +function raman_workspace(c, host, nt, chunk; modes=0, nodes=0, synthesis=nothing) host.flag("raman") || return nothing - T = c.T + T, C = c.T, Complex{c.T} rows, rates = host.array("raman_undamped", Float64), host.array("raman_rates", Float64) dt = host.real("dt") kernel = zeros(2nt) @@ -320,27 +327,68 @@ function raman_workspace(c, host, nt, chunk) kernel .*= host.real("raman_fraction") # The inverse transform is unnormalised: its 1/(2 nt) is folded into the kernel. spectrum = FFTW.rfft(kernel) .* (dt / (2nt)) - drive = dzeros(c, T, 2nt, chunk) - frequency = dzeros(c, Complex{T}, nt + 1, chunk) - (kernel=upload(c, Complex{T}.(spectrum)), factor=host.real("raman_factor"), - thg=host.flag("raman_thg"), drive=drive, frequency=frequency, + count = modes * (modes + 1) ÷ 2 + products = !c.envelope && synthesis !== nothing && nodes >= 2 && count < nodes && count <= chunk + columns = products ? count : chunk + drive = dzeros(c, T, 2nt, columns) + frequency = dzeros(c, C, nt + 1, columns) + thg = host.flag("raman_thg") + extra = (;) + if products + pairs = [(m, n) for m in 1:modes for n in m:modes] + weights = [synthesis[m, j] * synthesis[n, j] * (m == n ? 1 : 2) for (m, n) in pairs, j in 1:nodes] + signal = dzeros(c, C, thg ? 0 : nt, thg ? 0 : modes) + extra = (weights=upload(c, T.(weights)), nodal=dzeros(c, T, nt, chunk), + first=upload(c, first.(pairs)), second=upload(c, last.(pairs)), signal=signal, + signal_forward=thg ? nothing : plan(c, plan_fft!, signal, 1), + signal_inverse=thg ? nothing : plan(c, plan_bfft!, signal, 1)) + end + (kernel=upload(c, C.(spectrum)), factor=host.real("raman_factor"), thg=thg, + products=products, drive=drive, frequency=frequency, extra..., forward=plan(c, plan_rfft, drive, 1; threads=c.raman_fft_threads), inverse=plan(c, plan_brfft, frequency, 2nt, 1; threads=c.raman_fft_threads)) end +"""Convolve the drive's columns with the Raman kernel in place.""" +function convolve!(r, c) + (; drive, frequency, kernel) = r + @section :raman_forward mul!(frequency, r.forward, drive) + each!(c, size(frequency)...) do f, m + @inbounds frequency[f, m] *= kernel[f] + end + @section :raman_inverse mul!(drive, r.inverse, frequency) + nothing +end + """Convolve each node's drive, `|E|^2` (or half the analytic signal's), with the kernel.""" function raman_drive!(r, nodes, analytic, c, count) nt = size(nodes, 1) - (; drive, frequency, kernel) = r - thg = r.thg + drive, thg = r.drive, r.thg each!(c, 2nt, size(drive, 2)) do t, m @inbounds drive[t, m] = t > nt || m > count ? zero(eltype(drive)) : thg ? abs2(nodes[t, m]) : abs2(analytic[t, m]) / 2 end - mul!(frequency, r.forward, drive) - each!(c, nt + 1, size(drive, 2)) do f, m - @inbounds frequency[f, m] *= kernel[f] + convolve!(r, c) +end + +"""Convolve the modal products once a source: `a_m a_n`, or `Re(a_m conj a_n) / 2`.""" +function raman_products!(r, modal, c) + nt, modes = size(modal) + (; drive, first, second) = r + thg = r.thg + values = thg ? modal : r.signal + thg || analytic_signal!(r.signal, modal, r.signal_forward, r.signal_inverse, c, modes) + each!(c, 2nt, size(drive, 2)) do t, p + @inbounds begin + a, b = values[t, first[p]], values[t, second[p]] + drive[t, p] = t > nt ? zero(eltype(drive)) : thg ? real(a) * real(b) : + (real(a) * real(b) + imag(a) * imag(b)) / 2 + end end - mul!(drive, r.inverse, frequency) - nothing + convolve!(r, c) end + +"""A chunk's convolved node drives, rebuilt from the convolved products.""" +raman_nodal!(r, first, last, c) = + gemm!(@view(r.nodal[:, 1:last-first+1]), @view(r.drive[1:size(r.nodal, 1), :]), + @view(r.weights[:, first:last]), true, false, c) diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 3d3933e75..976dd3821 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -243,13 +243,9 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: control, tableau = problem.stepper.controller, problem.stepper.tableau chunk = min(transform.node_chunk, transform.n_nodes) temporal_columns = chunk if transform.kind == "free" else shape[1] - # Short one-column transforms lose to task startup. The Xeon A/B sweep - # retained serial transforms below 16k real-side samples, a four-thread cap - # above it, and an independent cap for the doubled Raman convolution. - fft_default = 1 if grids.n_to * temporal_columns < 16384 else min(threads, 4) - raman_default = 1 if 2 * grids.n_to * chunk < 16384 else min(threads, 4) - fft_threads = thread_limit("SOLPROP_JULIA_FFT_THREADS", fft_default) - blas_default = 1 if transform.kind == "mode_averaged" else min(threads, 4) + # One pool runs every pass, transforms and products included (julia/src/launch.jl): + # a transform is split into at most this many blocks of whole columns. + fft_threads = thread_limit("SOLPROP_JULIA_FFT_THREADS", threads) config: dict[str, object] = { "adams_order": problem.stepper.integrator.order if isinstance(problem.stepper.integrator, Multistep) @@ -309,11 +305,9 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: and problem.stepper.propagator_mode != "recompute", "threads": threads, "fft_threads": fft_threads, - "raman_fft_threads": thread_limit( - "SOLPROP_JULIA_RAMAN_FFT_THREADS", raman_default - ), + "raman_fft_threads": fft_threads, "transverse_fft_threads": fft_threads, - "blas_threads": thread_limit("SOLPROP_JULIA_BLAS_THREADS", blas_default), + "blas_threads": 1, "chunk": transform.node_chunk, "device": os.environ.get("SOLPROP_JULIA_DEVICE", "cpu"), } @@ -449,7 +443,7 @@ def __init__( self._varying = _varying(problem) if self._varying: self._prepare_stages(0.0, 0.0) - self._plan_flag = os.environ.get("SOLPROP_FFTW_PLAN") or "native policy" + self._plan_flag = os.environ.get("SOLPROP_FFTW_PLAN") or "measure" self._weight = ( np.empty(0) if problem.transform.geometry is not None From 647f362a7e709bbaf0a64317550d49f28b60718a Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 14:25:21 +0000 Subject: [PATCH 005/107] Julia: a CUDA extension and its environment [skip ci] SOLPROP_JULIA_DEVICE=cuda loads julia/cuda, CUDA.jl resolved together with the engine, whose extension makes its arrays CuArrays; every pass is the same body as on a CPU. Co-Authored-By: Claude Opus 5.5 --- julia/Manifest.toml | 8 +- julia/Project.toml | 6 + julia/bootstrap.py | 25 +- julia/cuda/Manifest.toml | 1193 ++++++++++++++++++++++++ julia/cuda/Project.toml | 6 + julia/ext/SolpropJuliaCUDAExt.jl | 13 + julia/src/responses.jl | 20 +- src/solprop/backends/julia/_runtime.py | 18 +- 8 files changed, 1261 insertions(+), 28 deletions(-) create mode 100644 julia/cuda/Manifest.toml create mode 100644 julia/cuda/Project.toml create mode 100644 julia/ext/SolpropJuliaCUDAExt.jl diff --git a/julia/Manifest.toml b/julia/Manifest.toml index 628851217..709a415ce 100644 --- a/julia/Manifest.toml +++ b/julia/Manifest.toml @@ -2,7 +2,7 @@ julia_version = "1.13.3" manifest_format = "2.1" -project_hash = "fa29c7ab8044951428f5c6a1cb0f867920a4aac6" +project_hash = "6fe1a72221429eac96c1944ecdaeb78d27aa4d11" [[deps.AbstractFFTs]] deps = ["LinearAlgebra"] @@ -708,6 +708,12 @@ path = "." uuid = "bc9db228-6fd1-46b1-b175-748485922872" version = "0.0.0" + [deps.SolpropJulia.extensions] + SolpropJuliaCUDAExt = "CUDA" + + [deps.SolpropJulia.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + [[deps.Static]] deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" diff --git a/julia/Project.toml b/julia/Project.toml index ecd2a82a3..e38973827 100644 --- a/julia/Project.toml +++ b/julia/Project.toml @@ -9,6 +9,12 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +[weakdeps] +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + +[extensions] +SolpropJuliaCUDAExt = "CUDA" + [compat] Polyester = "0.7.19" julia = "1.13" diff --git a/julia/bootstrap.py b/julia/bootstrap.py index bcd3bb64a..c89a69f5b 100644 --- a/julia/bootstrap.py +++ b/julia/bootstrap.py @@ -75,17 +75,20 @@ def main() -> None: "JULIA_CONDAPKG_BACKEND": "Null", "JULIA_PYTHONCALL_EXE": sys.executable, } - subprocess.run( - [ - str(executable()), - "--startup-file=no", - f"--project={ROOT / 'julia'}", - "-e", - "using Pkg; Pkg.instantiate(); Pkg.precompile()", - ], - env=env, - check=True, - ) + # --cuda also prepares the GPU environment, which adds CUDA.jl to the engine's. + projects = ["julia", "julia/cuda"] if "--cuda" in sys.argv[1:] else ["julia"] + for project in projects: + subprocess.run( + [ + str(executable()), + "--startup-file=no", + f"--project={ROOT / project}", + "-e", + "using Pkg; Pkg.instantiate(); Pkg.precompile()", + ], + env=env, + check=True, + ) sys.stdout.write(f"Prepared Julia and julia/Manifest.toml\n") diff --git a/julia/cuda/Manifest.toml b/julia/cuda/Manifest.toml new file mode 100644 index 000000000..57d06b13d --- /dev/null +++ b/julia/cuda/Manifest.toml @@ -0,0 +1,1193 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "60dba2cdeb11e87dd9cdcd5538ae5413f859500e" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" +weakdeps = ["CUDA", "CUDACore"] + +[[deps.BFloat16s]] +deps = ["LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "59ba860cf4d7e2fe58f35c8d08cfe765b6c33655" +registries = "General" +uuid = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" +version = "0.6.5" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CUDA]] +deps = ["CUDACore", "CUDATools", "Reexport", "cuBLAS", "cuFFT", "cuRAND", "cuSOLVER", "cuSPARSE"] +git-tree-sha1 = "c82345f5d7e0d902793b4ad5ddf61c2a8b6aac75" +registries = "General" +uuid = "052768ef-5323-5732-b1bb-66c8b64840ba" +version = "6.5.1" + +[[deps.CUDACore]] +deps = ["Adapt", "BFloat16s", "CEnum", "CUDA_Compiler_jll", "CUDA_Driver_jll", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUArrays", "GPUCompiler", "GPUToolbox", "KernelAbstractions", "KernelInterface", "LLVM", "LLVMLoopInfo", "LazyArtifacts", "Libdl", "LinearAlgebra", "Logging", "NVPTX_LLVM_Backend_jll", "PrecompileTools", "Preferences", "Printf", "Random", "Random123", "RandomNumbers", "ScopedValues", "UnsafeAtomics"] +git-tree-sha1 = "ad63644ab7a9fca22269c196e539d6c2ad75e841" +registries = "General" +uuid = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" +version = "6.5.1" + + [deps.CUDACore.extensions] + ChainRulesCoreExt = "ChainRulesCore" + EnzymeCoreExt = "EnzymeCore" + SpecialFunctionsExt = "SpecialFunctions" + StaticArraysExt = "StaticArrays" + + [deps.CUDACore.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.CUDATools]] +deps = ["CUDACore", "CUDA_Compiler_jll", "CUPTI", "Crayons", "GPUCompiler", "KernelInterface", "LLVM", "NVML", "NVTX", "PrecompileTools", "Preferences", "PrettyTables", "Printf", "Statistics", "demumble_jll"] +git-tree-sha1 = "de1d79e7ea89bbc09b844af32d651c77a9b6e300" +registries = "General" +uuid = "9ec180c6-1c07-47c7-9e6e-ebefa4d1f6d0" +version = "6.5.1" + +[[deps.CUDA_Compiler_jll]] +deps = ["Artifacts", "CUDA_Driver_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"] +git-tree-sha1 = "d25781968aff72a9d8d5bd979b7805d154ab45a0" +registries = "General" +uuid = "d1e2174e-dfdc-576e-b43e-73b79eb1aca8" +version = "0.6.4+0" + +[[deps.CUDA_Driver_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "8794abb9272b6c0791863549ab3aa32eee29bf7d" +registries = "General" +uuid = "4ee394cb-3365-5eb0-8335-949819d2adfc" +version = "13.5.0+0" + +[[deps.CUDA_Runtime_Discovery]] +deps = ["Libdl"] +git-tree-sha1 = "159b1c1f03e6355bb9c6d8954e5f51019788dd26" +registries = "General" +uuid = "1af6417a-86b4-443c-805f-a4643ffb695f" +version = "2.1.1" + +[[deps.CUDA_Runtime_jll]] +deps = ["Artifacts", "CUDA_Compiler_jll", "CUDA_Driver_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "MSVCRuntime_jll", "TOML"] +git-tree-sha1 = "6269b71d191c0081b8fb3ff5945c2a57f16231d4" +registries = "General" +uuid = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" +version = "0.25.0+3" + +[[deps.CUPTI]] +deps = ["CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUToolbox", "Libdl"] +git-tree-sha1 = "8ad5ff580bd0e7455905d3f8eed0c373bd8b2882" +registries = "General" +uuid = "9e67e8f6-ba02-4b6c-a7db-3b11ae1e7ab7" +version = "6.5.1" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CondaPkg]] +deps = ["FileWatching", "JSON", "Markdown", "MicroMamba", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "5105aafa8fedef75ad7f44d7dbf85a1b7196e406" +registries = "General" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.38" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Crayons]] +git-tree-sha1 = "54b76cbb40d9a0f5368c880725b2f141da77c94f" +registries = "General" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.2.0" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArrays]] +deps = ["AcceleratedKernels", "Adapt", "GPUArraysCore", "KernelAbstractions", "LLVM", "LinearAlgebra", "Printf", "Random", "Reexport", "ScopedValues", "Serialization", "SparseArrays", "Statistics"] +git-tree-sha1 = "1cd2703c11e873a60d0182b6806217a26d71d252" +registries = "General" +uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" +version = "12.2.0" + + [deps.GPUArrays.extensions] + JLD2Ext = "JLD2" + + [deps.GPUArrays.weakdeps] + JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaNVTXCallbacks_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "af433a10f3942e882d3c671aacb203e006a5808f" +registries = "General" +uuid = "9c1d0b0a-7046-5b2e-a33f-ea22f176ac7e" +version = "0.2.1+0" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" +weakdeps = ["BFloat16s"] + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMLoopInfo]] +git-tree-sha1 = "2e5c102cfc41f48ae4740c7eca7743cc7e7b75ea" +registries = "General" +uuid = "8b046642-f1f6-4319-8d3c-209ddc03c586" +version = "1.0.0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "f88f3ccef05a6a72a0cf0ed417c8fd68530f4ab2" +registries = "General" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.1" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MSVCRuntime_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "9670d7b2dbc92652a250e88eaa80861892d453e2" +registries = "General" +uuid = "ce32ce21-2cee-52aa-a084-5c6dad4fa7db" +version = "14.51.36247+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +registries = "General" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NVML]] +deps = ["CEnum", "CUDACore", "GPUToolbox", "Libdl"] +git-tree-sha1 = "75532531b1af772ab58b7ad513fe086aecb82e0a" +registries = "General" +uuid = "611af6d1-644e-4c5d-bd58-854d7d1254b9" +version = "6.5.1" + +[[deps.NVPTX_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "839f120ee970f8216f91034ce8e0436bf5b04ce3" +registries = "General" +uuid = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" +version = "23.1.2+2" + +[[deps.NVTX]] +deps = ["JuliaNVTXCallbacks_jll", "Libdl", "NVTX_jll"] +git-tree-sha1 = "a9083c3e469e63cca454d1fc3b19472d9d92c14a" +registries = "General" +uuid = "5da4648a-3479-48b8-97b9-01cb529c0a1f" +version = "1.0.3" + + [deps.NVTX.extensions] + NVTXColorsExt = "Colors" + + [deps.NVTX.weakdeps] + Colors = "5ae59095-9a9b-59fe-a467-6f913c188581" + +[[deps.NVTX_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "af2232f69447494514c25742ba1503ec7e9877fe" +registries = "General" +uuid = "e98f9f5b-d649-5603-91fd-7774390e6439" +version = "3.2.2+0" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "b079a6affebde167dad8ffe0d670b53917fbcb68" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "2.0.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "StyledStrings", "Tables"] +git-tree-sha1 = "eeac4c9337f876c3c32b8da732141953567f57c9" +registries = "General" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.5.1" + + [deps.PrettyTables.extensions] + PrettyTablesExcelExt = "XLSX" + PrettyTablesTypstryExt = "Typstry" + PrettyTablesWriteDocxExt = "WriteDocx" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + WriteDocx = "d049ceea-54ee-41d7-a26f-ba29db3b6599" + XLSX = "fdbf4ff8-1666-58a4-91e7-1b58723a45e0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Preferences", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "00d3a883b716a8482da76d08dae1f6084bbfeb23" +registries = "General" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.37" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "6aaddfdf3040d02a5b3e10c6cd0e4e1dce27f23c" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+1" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SolpropJulia]] +deps = ["AcceleratedKernels", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +path = ".." +uuid = "bc9db228-6fd1-46b1-b175-748485922872" +version = "0.0.0" +weakdeps = ["CUDA"] + + [deps.SolpropJulia.extensions] + SolpropJuliaCUDAExt = "CUDA" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.13.0" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StringManipulation]] +deps = ["PrecompileTools", "StyledStrings"] +git-tree-sha1 = "9e3a02d73a8f0a9be04e677dbef758aab40f8bea" +registries = "General" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.6.1" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.10.1+0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +registries = "General" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.cuBLAS]] +deps = ["Adapt", "BFloat16s", "CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUArrays", "GPUToolbox", "LLVM", "LinearAlgebra"] +git-tree-sha1 = "4a182d7bc3a87868d963eeeb12277cb8a825eaea" +registries = "General" +uuid = "182d3088-87b7-4494-8cad-fc6afaa545bc" +version = "6.5.1" + + [deps.cuBLAS.extensions] + EnzymeCoreExt = "EnzymeCore" + + [deps.cuBLAS.weakdeps] + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + +[[deps.cuFFT]] +deps = ["AbstractFFTs", "CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUToolbox", "LinearAlgebra", "Reexport"] +git-tree-sha1 = "275873c4d33d11b2df748c3f3458ab1f1b21eddb" +registries = "General" +uuid = "533571aa-0936-420e-b4be-9c66f5f626ca" +version = "6.5.1" + +[[deps.cuRAND]] +deps = ["CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUToolbox", "Random", "Random123", "RandomNumbers"] +git-tree-sha1 = "20b8515e542b3dd01beb5dd69ca685531274ff68" +registries = "General" +uuid = "20fd9a0b-12d5-4c2f-a8af-7c34e9e60431" +version = "6.5.1" + +[[deps.cuSOLVER]] +deps = ["CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUToolbox", "LinearAlgebra", "SparseArrays", "cuBLAS", "cuSPARSE"] +git-tree-sha1 = "9a985ead9bf3314add409c2ff2652d1317e0851f" +registries = "General" +uuid = "887afef0-6a32-4de5-add4-7827692ba8fc" +version = "6.5.1" + +[[deps.cuSPARSE]] +deps = ["Adapt", "CEnum", "CUDACore", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "GPUArrays", "GPUToolbox", "KernelInterface", "LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "025dfe67c4257440206ed720ea5445ed5336d425" +registries = "General" +uuid = "b26da814-b3bc-49ef-b0ee-c816305aa060" +version = "6.5.1" + + [deps.cuSPARSE.extensions] + SparseMatricesCSRExt = "SparseMatricesCSR" + + [deps.cuSPARSE.weakdeps] + SparseMatricesCSR = "a0a7dd2c-ebf4-11e9-1f05-cf50bc540ca1" + +[[deps.demumble_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6498e3581023f8e530f34760d18f75a69e3a4ea8" +registries = "General" +uuid = "1e29f10c-031c-5a83-9565-69cddfc27673" +version = "1.3.0+0" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +registries = "General" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "56c56fede8f01e1be7e2fdf1eb911487640619a0" +registries = "General" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.76.2+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/cuda/Project.toml b/julia/cuda/Project.toml new file mode 100644 index 000000000..bd90c9aff --- /dev/null +++ b/julia/cuda/Project.toml @@ -0,0 +1,6 @@ +[deps] +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +SolpropJulia = "bc9db228-6fd1-46b1-b175-748485922872" + +[sources] +SolpropJulia = {path = ".."} diff --git a/julia/ext/SolpropJuliaCUDAExt.jl b/julia/ext/SolpropJuliaCUDAExt.jl new file mode 100644 index 000000000..0e6ca955f --- /dev/null +++ b/julia/ext/SolpropJuliaCUDAExt.jl @@ -0,0 +1,13 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# NVIDIA GPUs: the engine's arrays become CuArrays, its transforms cuFFT plans and its +# products cuBLAS calls; every pass is the same scalar body as on a CPU. +module SolpropJuliaCUDAExt +using CUDA +import SolpropJulia + +SolpropJulia.device_backend(::Val{:cuda}) = (CUDA.allowscalar(false); CUDABackend()) +SolpropJulia.device_label(::CUDABackend) = "cuda: " * CUDA.name(CUDA.device()) + +end diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 9bd4190e9..1fadb9556 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -375,14 +375,18 @@ end function raman_products!(r, modal, c) nt, modes = size(modal) (; drive, first, second) = r - thg = r.thg - values = thg ? modal : r.signal - thg || analytic_signal!(r.signal, modal, r.signal_forward, r.signal_inverse, c, modes) - each!(c, 2nt, size(drive, 2)) do t, p - @inbounds begin - a, b = values[t, first[p]], values[t, second[p]] - drive[t, p] = t > nt ? zero(eltype(drive)) : thg ? real(a) * real(b) : - (real(a) * real(b) + imag(a) * imag(b)) / 2 + if r.thg + each!(c, 2nt, size(drive, 2)) do t, p + @inbounds drive[t, p] = t > nt ? zero(eltype(drive)) : modal[t, first[p]] * modal[t, second[p]] + end + else + signal = r.signal + analytic_signal!(signal, modal, r.signal_forward, r.signal_inverse, c, modes) + each!(c, 2nt, size(drive, 2)) do t, p + @inbounds begin + a, b = signal[t, first[p]], signal[t, second[p]] + drive[t, p] = t > nt ? zero(eltype(drive)) : (real(a) * real(b) + imag(a) * imag(b)) / 2 + end end end convolve!(r, c) diff --git a/src/solprop/backends/julia/_runtime.py b/src/solprop/backends/julia/_runtime.py index e7d0285ae..fa0bec608 100644 --- a/src/solprop/backends/julia/_runtime.py +++ b/src/solprop/backends/julia/_runtime.py @@ -110,6 +110,13 @@ def runtime() -> Any: "julia requires a source checkout with a prepared Julia 1.13 runtime; " "follow julia/README.md" ) + device = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") + if device not in {"cpu", "cuda"}: + raise BackendError("SOLPROP_JULIA_DEVICE must be cpu or cuda") + # A GPU run's environment adds CUDA.jl to the engine's, resolved with it, so + # that a CPU run never resolves or loads the GPU packages. + if device == "cuda": + project = project / "cuda" settings = { "PYTHON_JULIACALL_EXE": str(executable), "PYTHON_JULIACALL_PROJECT": str(project), @@ -121,14 +128,7 @@ def runtime() -> Any: ), "JULIA_CONDAPKG_BACKEND": "Null", } - device = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") - if device not in {"cpu", "cuda"}: - raise BackendError("SOLPROP_JULIA_DEVICE must be cpu or cuda") - # The CUDA packages live in a second environment stacked on the project's, so a - # CPU run never resolves or loads them. - settings["JULIA_LOAD_PATH"] = ( - f"@:{project / 'cuda'}:@stdlib" if device == "cuda" else "@:@stdlib" - ) + settings["JULIA_LOAD_PATH"] = "@:@stdlib" # The experiment deliberately owns one Julia runtime per Python process. for name, value in settings.items(): if name in os.environ and os.environ[name] != value: @@ -164,6 +164,8 @@ def source_digest() -> str: *(root / "julia/ext").rglob("*.jl"), root / "julia/Project.toml", root / "julia/Manifest.toml", + root / "julia/cuda/Project.toml", + root / "julia/cuda/Manifest.toml", *Path(__file__).parent.glob("*.py"), ] ) From 8226186eb194a3a2f5091752b36d22111226cd9a Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 14:28:53 +0000 Subject: [PATCH 006/107] Julia: name the checkout for an installed solprop [skip ci] Co-Authored-By: Claude Opus 5.5 --- julia/bench/Manifest.toml | 139 ++++++++++++++++++++++++- julia/bench/Project.toml | 1 + src/solprop/backends/julia/_runtime.py | 29 ++++-- 3 files changed, 161 insertions(+), 8 deletions(-) diff --git a/julia/bench/Manifest.toml b/julia/bench/Manifest.toml index 685fda506..0ccd38909 100644 --- a/julia/bench/Manifest.toml +++ b/julia/bench/Manifest.toml @@ -2,7 +2,22 @@ julia_version = "1.13.3" manifest_format = "2.1" -project_hash = "e1d577ebc9294ccc85c82473e39d27b364d15f68" +project_hash = "c560532eae82ee8bc885fc8fd09c5b5f824bb120" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [[deps.AcceleratedKernels]] deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] @@ -70,6 +85,10 @@ registries = "General" uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" version = "2.5.0" +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + [[deps.ArrayInterface]] deps = ["Adapt", "LinearAlgebra"] git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" @@ -260,12 +279,31 @@ deps = ["Printf"] uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" version = "1.11.0" +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + [[deps.ExprTools]] git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" registries = "General" uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" version = "0.1.11" +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + [[deps.FileWatching]] uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" version = "1.11.0" @@ -328,6 +366,13 @@ registries = "General" uuid = "22cec73e-a1b8-11e9-2c92-598750a2cf9c" version = "0.3.1" +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + [[deps.InteractiveUtils]] deps = ["Markdown"] uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" @@ -451,6 +496,36 @@ registries = "General" uuid = "10f19ff3-798f-405d-979b-55457f8fc047" version = "0.1.17" +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + [[deps.LibTracyClient_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" @@ -478,6 +553,13 @@ version = "1.13.0" uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" version = "1.11.0" +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + [[deps.MacroTools]] git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" registries = "General" @@ -495,6 +577,14 @@ deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" version = "1.11.0" +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + [[deps.OhMyThreads]] deps = ["BangBang", "ChunkSplitters", "ScopedValues", "StableTasks", "TaskLocalValues"] git-tree-sha1 = "a73a90d87e3f941f5084d34d56934c2fb59dd9b1" @@ -515,6 +605,16 @@ deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" version = "0.3.30+0" +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + [[deps.Parsers]] deps = ["Dates", "PrecompileTools"] git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" @@ -522,6 +622,15 @@ registries = "General" uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" version = "3.0.6" +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + [[deps.Polyester]] deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" @@ -584,6 +693,12 @@ registries = "General" uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" version = "1.6.0" +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + [[deps.SHA]] uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" version = "1.0.0" @@ -743,6 +858,11 @@ deps = ["Dates"] uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" version = "1.0.3" +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + [[deps.TaskLocalValues]] git-tree-sha1 = "67e469338d9ce74fc578f7db1736a74d93a49eb8" registries = "General" @@ -818,6 +938,23 @@ deps = ["Artifacts", "Libdl"] uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" version = "5.15.0+0" +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + [[deps.pocl_standalone_jll]] deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" diff --git a/julia/bench/Project.toml b/julia/bench/Project.toml index 89be2e44a..3ff7af190 100644 --- a/julia/bench/Project.toml +++ b/julia/bench/Project.toml @@ -1,6 +1,7 @@ [deps] AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" OhMyThreads = "67456a42-1dca-4109-a031-0a68de7e3ad5" Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" diff --git a/src/solprop/backends/julia/_runtime.py b/src/solprop/backends/julia/_runtime.py index fa0bec608..461e9db26 100644 --- a/src/solprop/backends/julia/_runtime.py +++ b/src/solprop/backends/julia/_runtime.py @@ -80,8 +80,8 @@ def runtime() -> Any: """Load the experimental Julia module from this source checkout. ``SOLPROP_JULIA_EXE`` names the Julia 1.13 executable (default: the one - ``julia/bootstrap.py`` downloads) and ``SOLPROP_JULIA_DEPOT`` its package depot - (default ``.julia-depot``). ``SOLPROP_JULIA_DEVICE=cuda`` loads CUDA.jl first, so + ``julia/bootstrap.py`` downloads), ``SOLPROP_JULIA_DEPOT`` its package depot + (default ``.julia-depot``) and ``SOLPROP_JULIA_ROOT`` the checkout (`checkout`). ``SOLPROP_JULIA_DEVICE=cuda`` loads CUDA.jl first, so that the engine's CUDA extension is available. Returns @@ -94,7 +94,7 @@ def runtime() -> Any: BackendError If the runtime or Julia project has not been prepared. """ - root = Path(__file__).resolve().parents[4] + root = checkout() if "juliacall" in sys.modules: raise BackendError( "julia requires a fresh Python process: JuliaCall was already initialized" @@ -145,6 +145,21 @@ def runtime() -> Any: return module.SolpropJulia +def checkout() -> Path: + """Return the source checkout whose ``julia/`` project the engine runs. + + ``SOLPROP_JULIA_ROOT`` names it for an installed (non-editable) solprop; by + default it is the checkout this module was imported from. + + Returns + ------- + pathlib.Path + The checkout's root directory. + """ + named = os.environ.get("SOLPROP_JULIA_ROOT") + return Path(named) if named else Path(__file__).resolve().parents[4] + + def source_digest() -> str: """Return a SHA-256 over the Julia sources, the manifest and this adapter. @@ -157,7 +172,7 @@ def source_digest() -> str: str Hexadecimal digest. """ - root = Path(__file__).resolve().parents[4] + root = checkout() paths = sorted( [ *(root / "julia/src").rglob("*.jl"), @@ -166,12 +181,12 @@ def source_digest() -> str: root / "julia/Manifest.toml", root / "julia/cuda/Project.toml", root / "julia/cuda/Manifest.toml", - *Path(__file__).parent.glob("*.py"), ] ) + adapter = sorted(Path(__file__).parent.glob("*.py")) digest = hashlib.sha256() - for path in paths: + for path in [*paths, *adapter]: if path.is_file(): - digest.update(str(path.relative_to(root)).encode()) + digest.update(path.name.encode()) digest.update(path.read_bytes()) return digest.hexdigest() From b6b6d05c6de78b26cd532f944625977b4d2b383e Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 14:52:56 +0000 Subject: [PATCH 007/107] Julia: monitor reductions in the engine, zero-copy views, precompiled entries [skip ci] The boundary monitor's power, the split's found power (formed inside the commit from the transform the split already does) and the crossing's occupancy are reduced by the engine; only short vectors cross. States cross the bridge as column-major views with one owning copy. create() compiles every entry point for the engine's types, so a run's first steps no longer pay seconds of JIT inside the timed propagation. Co-Authored-By: Claude Opus 5.5 --- julia/Manifest.toml | 4 +- julia/Project.toml | 2 + julia/cuda/Manifest.toml | 4 +- julia/cuda/Project.toml | 1 + julia/src/SolpropJulia.jl | 33 +++++++- julia/src/dopri.jl | 11 ++- julia/src/free.jl | 10 +-- julia/src/launch.jl | 28 +++++++ julia/src/modal.jl | 1 + julia/src/observe.jl | 102 +++++++++++++++++++++++++ src/solprop/backends/julia/_backend.py | 91 ++++++++++++++++++---- 11 files changed, 257 insertions(+), 30 deletions(-) create mode 100644 julia/src/observe.jl diff --git a/julia/Manifest.toml b/julia/Manifest.toml index 709a415ce..a8c81332a 100644 --- a/julia/Manifest.toml +++ b/julia/Manifest.toml @@ -2,7 +2,7 @@ julia_version = "1.13.3" manifest_format = "2.1" -project_hash = "6fe1a72221429eac96c1944ecdaeb78d27aa4d11" +project_hash = "0ebf08b9c460789dacbdc3ddc7c3310f1b94422b" [[deps.AbstractFFTs]] deps = ["LinearAlgebra"] @@ -703,7 +703,7 @@ uuid = "6462fe0b-24de-5631-8697-dd941f90decc" version = "1.11.0" [[deps.SolpropJulia]] -deps = ["AcceleratedKernels", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] path = "." uuid = "bc9db228-6fd1-46b1-b175-748485922872" version = "0.0.0" diff --git a/julia/Project.toml b/julia/Project.toml index e38973827..c62530a5e 100644 --- a/julia/Project.toml +++ b/julia/Project.toml @@ -3,6 +3,7 @@ uuid = "bc9db228-6fd1-46b1-b175-748485922872" [deps] AcceleratedKernels = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +Atomix = "a9b6321e-bd34-4604-b9c9-b65b8de01458" FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" @@ -16,5 +17,6 @@ CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" SolpropJuliaCUDAExt = "CUDA" [compat] +Atomix = "1.7.0" Polyester = "0.7.19" julia = "1.13" diff --git a/julia/cuda/Manifest.toml b/julia/cuda/Manifest.toml index 57d06b13d..9ca39d7e8 100644 --- a/julia/cuda/Manifest.toml +++ b/julia/cuda/Manifest.toml @@ -2,7 +2,7 @@ julia_version = "1.13.3" manifest_format = "2.1" -project_hash = "60dba2cdeb11e87dd9cdcd5538ae5413f859500e" +project_hash = "7636c761c1c4063c6f7788bd9869f847b902626f" [[deps.AbstractFFTs]] deps = ["LinearAlgebra"] @@ -870,7 +870,7 @@ uuid = "6462fe0b-24de-5631-8697-dd941f90decc" version = "1.11.0" [[deps.SolpropJulia]] -deps = ["AcceleratedKernels", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] path = ".." uuid = "bc9db228-6fd1-46b1-b175-748485922872" version = "0.0.0" diff --git a/julia/cuda/Project.toml b/julia/cuda/Project.toml index bd90c9aff..ba6bfa555 100644 --- a/julia/cuda/Project.toml +++ b/julia/cuda/Project.toml @@ -1,5 +1,6 @@ [deps] CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" SolpropJulia = "bc9db228-6fd1-46b1-b175-748485922872" [sources] diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index d29c2f4cc..65b7435f2 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -18,6 +18,7 @@ using PythonCall using Polyester: @batch import AcceleratedKernels as AK import KernelAbstractions as KA +import Atomix # The digest of the sources this module was loaded from, set by the Python loader. const SOURCE_DIGEST = Ref("") @@ -41,6 +42,7 @@ include("dopri.jl") include("rk4.jl") include("adams.jl") include("stages.jl") +include("observe.jl") real_type(engine) = real(eltype(engine.work.y)) @@ -66,10 +68,34 @@ function create(input) rtol=host.real("rtol"), atol=host.real("atol"), cache_propagators=host.has("cache_propagators") ? host.flag("cache_propagators") : true, ) - c.free ? create_free(c, host) : create_modal(c, host) + engine = c.free ? create_free(c, host) : create_modal(c, host) + compile!(engine) + engine +end + +"""Compile every entry point the march calls for this engine's types, now. + +Construction is timed apart from propagation; without this, a run's first step and +first boundary reading pay seconds of compilation inside the propagation's time. +""" +function compile!(engine) + E = typeof(engine) + for (f, arguments) in ((trial!, (E, Float64)), (commit!, (E, Float64, Bool)), + (rk4!, (E, Float64, Float64)), (state_power, (E,)), + (split_power, (E,)), (occupancy, (E,)), (host_state, (E,)), + (host_candidate, (E,)), (adams_start!, (E,)), (adams_accept!, (E, Int)), + (material_stage!, (E, Int)), (reset!, (E,))) + precompile(f, arguments) + end + a = engine.work.adams + if a !== nothing + for n in 1:size(a.moments, 3) + precompile(adams_trial_width!, (E, Float64, Val{n})) + end + end + nothing end -load!(engine, input) = (copyto!(engine.work.y, device_matrix(engine, input)); reset!(engine)) function reset!(engine) mask!(engine, engine.work.y) engine.fsal_valid = false @@ -88,8 +114,6 @@ function mask!(engine, values) end end -snapshot(engine) = complex_host(engine.work.y) -candidate(engine) = complex_host(engine.work.candidate) complex_host(a) = Matrix{ComplexF64}(Array(a)) function evaluate!(engine, input) copyto!(engine.work.lab, device_matrix(engine, input)) @@ -122,6 +146,7 @@ runtime() = (string(VERSION), Threads.nthreads(), FFTW.get_num_threads(), const rk4_b = rk4! const configure_stages_b = configure_stages! const load_b = load! +const bind_monitor_b = bind_monitor! const trial_b = trial! const commit_b = commit! const evaluate_b = evaluate! diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index ffca720df..7b7b56f51 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -121,11 +121,12 @@ function weighted_norm(engine, error, magnitude) end """Accept the candidate: the mask, the split-step collar, then the quadrature alarm.""" -function commit!(engine, dz::Float64) +function commit!(engine, dz::Float64, monitored::Bool=false) c, w = engine.config, engine.work mask!(engine, w.candidate) if c.split_active - c.free ? split_free!(engine, dz) : split_modal!(engine, dz) + # With a split monitor bound, the power the split finds (`split_power`). + c.free ? split_free!(engine, dz, monitored) : split_modal!(engine, dz, monitored) mask!(engine, w.candidate) engine.fsal_valid = false elseif !c.low_storage && w.adams === nothing @@ -137,10 +138,14 @@ function commit!(engine, dz::Float64) c.embedded ? quadrature_alarm(engine) : NaN end -function split_modal!(engine, dz) +function split_modal!(engine, dz, monitored) c, w = engine.config, engine.work (; coarse) = w mul!(coarse, w.coarse_inverse, w.candidate) + if monitored + fill!(w.monitor.split, 0) + add_power!(w.monitor.split, coarse, w.monitor.columns, 1, size(coarse, 2), c) + end rate = c.coarse_rate T = real_type(engine) # The unnormalised inverse's 1/nc is folded into the collar's factor. diff --git a/julia/src/free.jl b/julia/src/free.jl index 78e896745..ce0e84cd9 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -43,7 +43,7 @@ function create_free(c, host) coarse, coarse_spec = dzeros(c, R, nc, chunk), dzeros(c, C, nw, chunk) planes = (threads=c.transverse_fft_threads, batch=1) work = ( - adams=nothing, path=nothing, raman=nothing, + adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), plasma=plasma_workspace(c, host, nt, chunk, chunk, nm), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), @@ -226,7 +226,7 @@ function gather_columns!(physical, fine, loss, absorber_spec, first, count, c) end end -function split_free!(engine, dz) +function split_free!(engine, dz, monitored) c, w = engine.config, engine.work (; physical, coarse, coarse_spec) = w copyto!(physical, w.candidate) @@ -236,12 +236,12 @@ function split_free!(engine, dz) rate, half = c.coarse_rate, T(-0.5 * dz) # Both unnormalised inverses' 1/(nc n_x n_y) is folded into the collar's factor. inverse = inv(T(c.nc) * T(nm)) + monitored && fill!(w.monitor.split, 0) for first in 1:chunk:nm count = min(chunk, nm - first + 1) - each!(c, size(coarse_spec)...) do f, m - @inbounds coarse_spec[f, m] = m <= count ? physical[f, first+m-1] : zero(eltype(coarse_spec)) - end + columns_into!(coarse_spec, physical, first, count, c) mul!(coarse, w.coarse_inverse, coarse_spec) + monitored && add_power!(w.monitor.split, coarse, w.monitor.columns, first, count, c) each!(c, size(coarse)...) do t, m @inbounds coarse[t, m] *= exp(half * rate[t]) * inverse end diff --git a/julia/src/launch.jl b/julia/src/launch.jl index d44573a53..d6223ffe3 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -94,6 +94,34 @@ function each_column!(f::F, c, nm::Integer) where {F} nothing end +"""Set `out[t]` to the sum over `m` of `f(t, m)`: a reduction across columns. + +Each task (CPU) or thread (GPU) owns a block of rows, so no two write one sum. +""" +function rowsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} + nt, nm = Int(nt), Int(nm) + if oncpu(c) + rows = max(256, cld(nt, c.tasks)) + @batch for b in 1:cld(nt, rows) + r = (b-1)*rows+1:min(b * rows, nt) + for m in 1:nm + @inbounds @simd for t in r + out[t] += f(t, m) + end + end + end + else + AK.foreachindex(1:nt; backend=c.backend) do t + total = zero(eltype(out)) + for m in 1:nm + total += f(t, m) + end + @inbounds out[t] += total + end + end + nothing +end + """Return `op` folded over `f(t, m)` for every sample, starting from `neutral`. `op` must be associative and commutative: the order is the tiling's (CPU) or the diff --git a/julia/src/modal.jl b/julia/src/modal.jl index b9b9de22e..a0d028d34 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -58,6 +58,7 @@ function create_modal(c, host) band = dzeros(c, C, nw, nm) work = ( adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), + monitor=monitor_workspace(c, nw, nm, c.nc), raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), diff --git a/julia/src/observe.jl b/julia/src/observe.jl new file mode 100644 index 000000000..905232a41 --- /dev/null +++ b/julia/src/observe.jl @@ -0,0 +1,102 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# What the driver reads of the state between steps: the state itself, and the boundary +# monitor's reductions, formed here so that only short vectors cross (SEP 21, ADR-057). + +"""The accepted state, for the host: the engine's own array on a CPU in binary64.""" +host_state(engine) = host_view(engine.work.y) +host_candidate(engine) = host_view(engine.work.candidate) +host_view(a::Matrix{ComplexF64}) = a +host_view(a) = Matrix{ComplexF64}(Array(a)) + +"""Load a host state given as its (n_omega, n_modes) column-major view.""" +function load!(engine, input) + y = engine.work.y + if y isa Matrix{ComplexF64} + copyto!(y, PyArray(input)) + else + copyto!(y, Matrix{eltype(y)}(PyArray(input))) + end + reset!(engine) +end + +"""Hold the monitor's column weights and, for a split crossing, its rate buckets.""" +function bind_monitor!(engine, columns, buckets) + c, w = engine.config, engine.work + T = real_type(engine) + nm = size(w.y, 2) + weights = columns === nothing ? ones(T, nm) : T.(Vector{Float64}(columns)) + copyto!(w.monitor.columns, weights) + if buckets !== nothing + copyto!(w.monitor.buckets, Int32.(permutedims(Matrix{Int}(buckets))) .+ Int32(1)) + end + nothing +end +function monitor_workspace(c, nw, nm, nc) + (columns=dzeros(c, c.T, nm), buckets=dzeros(c, Int32, nw, nm), power=dzeros(c, c.T, nc), + split=dzeros(c, c.T, nc), histogram=dzeros(c, c.T, 128, c.tasks)) +end + +"""Add `sum_m w_m |x(t, m)|^2 / n^2` of unnormalised inverse samples into `power`.""" +function add_power!(power, samples, weights, first, count, c) + T = eltype(power) + scale = inv(T(size(samples, 1)))^2 + rowsum!(c, power, size(samples, 1), count) do t, m + @inbounds abs2(samples[t, m]) * weights[first+m-1] * scale + end +end + +"""`P(t)` of the accepted state on the coarse time axis: the monitor's `power`.""" +function state_power(engine) + c, w = engine.config, engine.work + (; power, columns) = w.monitor + fill!(power, 0) + if c.free + chunk, nm = size(w.coarse, 2), size(w.y, 2) + for first in 1:chunk:nm + count = min(chunk, nm - first + 1) + columns_into!(w.coarse_spec, w.y, first, count, c) + mul!(w.coarse, w.coarse_inverse, w.coarse_spec) + add_power!(power, w.coarse, columns, first, count, c) + end + else + # The c2r transform overwrites its input: the scratch takes a copy. + copyto!(w.lab, w.y) + mul!(w.coarse, w.coarse_inverse, w.lab) + add_power!(power, w.coarse, columns, 1, size(w.y, 2), c) + end + Vector{Float64}(Array(power)) +end +split_power(engine) = Vector{Float64}(Array(engine.work.monitor.split)) + +function columns_into!(target, source, first, count, c) + each!(c, size(target)...) do f, m + @inbounds target[f, m] = m <= count ? source[f, first+m-1] : zero(eltype(target)) + end +end + +"""The state's spectral energy in each of the split crossing's rate buckets.""" +function occupancy(engine) + c, w = engine.config, engine.work + (; buckets, columns, histogram) = w.monitor + y = w.y + nw, nm = size(y) + T = real_type(engine) + fill!(histogram, 0) + if oncpu(c) + tasks = size(histogram, 2) + @batch for k in 1:tasks + for m in k:tasks:nm, f in 1:nw + @inbounds histogram[buckets[f, m], k] += abs2(y[f, m]) * columns[m] + end + end + else + AK.foreachindex(1:nw*nm; backend=c.backend) do i + m = (i - 1) ÷ nw + 1 + f = i - (m - 1) * nw + @inbounds Atomix.@atomic histogram[buckets[f, m], 1] += abs2(y[f, m]) * columns[m] + end + end + vec(sum(Array{Float64}(Array(histogram)); dims=2)) +end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 976dd3821..32c8c6c2c 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -29,6 +29,7 @@ from solprop.exceptions import BackendError from solprop.grid import TimeGrid from solprop.modes.protocol import Mode +from solprop.monitor import BoundaryEnergies, BoundaryMonitor from solprop.noise import NoiseRealisation from solprop.output.schema import SavedPlane from solprop.profiles import ZProfile @@ -432,7 +433,8 @@ def __init__( self._jl = runtime() # The loaded module is the one on disk: a source edit after the runtime # started would otherwise time or test stale code. - if str(self._jl.loaded_digest()) != source_digest(): + self._digest = source_digest() + if str(self._jl.loaded_digest()) != self._digest: raise BackendError("julia sources changed after the runtime loaded them") self._threads = thread_limit("SOLPROP_JULIA_THREADS") if not 1 <= self._threads <= int(self._jl.runtime()[1]): @@ -507,7 +509,8 @@ def _apply_mask( object Opaque Julia engine handle. """ - call_julia(self._jl.load_b, self._engine, state[0, :, 0, :].T.copy()) + # A column-major (n_omega, n_modes) view: the engine copies it once. + call_julia(self._jl.load_b, self._engine, state[0, :, 0, :].T) self._fsal = False self._alarm = math.nan return self._engine @@ -636,15 +639,20 @@ def _finish(self, state: object, dz: float) -> object: object Opaque accepted state handle. """ - if (monitor := self._split_monitor) is not None and _splits(self._problem): - # What the split collar takes and finds, from the masked state before - # it, as the reference's finish reads it (SEP 21). - values = np.asarray(call_julia(self._jl.candidate, self._engine)) - masked = values.T[None, :, None, :] * self._problem.grids.active_mask - sums = monitor.split_sums(masked, dz) - self._split_removed += float(sums[0]) - self._split_found = sums[1:] - self._alarm = float(call_julia(self._jl.commit_b, self._engine, dz, nogil=True)) + monitor = self._split_monitor if _splits(self._problem) else None + self._alarm = float( + call_julia( + self._jl.commit_b, self._engine, dz, monitor is not None, nogil=True + ) + ) + if monitor is not None: + # What the split collar takes and finds, from the power of the masked + # state before it, which the commit formed: BoundaryMonitor.split_sums. + power = np.asarray(call_julia(self._jl.split_power, self._engine)) + rate = monitor.weights[3] + half = power * np.exp(-0.5 * rate * dz) + self._split_removed += float(power @ -np.expm1(-rate * dz)) + self._split_found = np.concatenate([[half.sum()], monitor.weights[:3] @ half]) if self._alarm > 1e-6 and not self._alarm_reported: self._alarm_reported = True logger.warning( @@ -675,8 +683,63 @@ def _observed_field( numpy.ndarray Independent complex128 host array in the seam layout. """ - values = np.asarray(call_julia(self._jl.snapshot, state), dtype=np.complex128) - return values.T.copy()[None, :, None, :] + # The engine's own column-major array, viewed: one copy makes it the host's. + values = np.asarray(call_julia(self._jl.host_state, state)) + return np.array(values.T, dtype=np.complex128)[None, :, None, :] + + def _bind_monitor(self, monitor: BoundaryMonitor | None) -> None: + """Hold the monitor's column weights and rate buckets in the engine. + + Parameters + ---------- + monitor : solprop.monitor.BoundaryMonitor or None + The run's monitor, or ``None`` to stop. + """ + super()._bind_monitor(monitor) + if monitor is None: + return + crossing = monitor.crossing + call_julia( + self._jl.bind_monitor_b, + self._engine, + None if monitor.columns is None else np.asarray(monitor.columns), + None if crossing is None else np.asarray(crossing.buckets), + ) + + def _boundary_energies(self, state: object) -> BoundaryEnergies: + """Read the monitor's energies from the engine's power, not a state copy. + + Parameters + ---------- + state : object + The accepted state handle. + + Returns + ------- + solprop.monitor.BoundaryEnergies + The reading. + + Raises + ------ + BackendError + If no monitor is attached. + """ + del state + monitor = self._monitor + if monitor is None: + raise BackendError("julia: no boundary monitor is attached") + removed, self._split_removed = self._split_removed, 0.0 + power = np.asarray(call_julia(self._jl.state_power, self._engine)) + crossing = monitor.crossing + return BoundaryEnergies( + float(power.sum()), + monitor.weights @ power, + removed=removed, + found=self._split_found, + occupancy=None + if crossing is None + else np.asarray(call_julia(self._jl.occupancy, self._engine)), + ) def stats(self, spec: StatsSpec) -> dict[str, np.ndarray]: """Collect supported modal or spatial statistics through shared host functions. @@ -801,7 +864,7 @@ def metadata(self) -> dict[str, object]: free = self._problem.transform.kind == "free" return super().metadata() | { "julia_version": str(version), - "julia_source_digest": source_digest(), + "julia_source_digest": self._digest, "device": str(self._jl.device_name(self._engine)), "resident_source_evaluations": int(self._engine.calls), "propagator_cache": ( From 8ab6c4b9d03ff3ca7a815b0fe1e2ba4d71e344f5 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 15:08:34 +0000 Subject: [PATCH 008/107] Julia: hold host BLAS to one thread; kernels capture values, not types [skip ci] NumPy's OpenBLAS spun beside the engine's pool after each host product and made a radial window four times slower; the engine leases every host BLAS pool at one thread for its lifetime, as native does. Kernel bodies capture zero values and scalars instead of element types, which a GPU kernel cannot take as arguments. Co-Authored-By: Claude Opus 5.5 --- julia/src/adams.jl | 27 +++++++++++++------------- julia/src/dopri.jl | 5 +++-- julia/src/responses.jl | 18 +++++++++-------- julia/src/rk4.jl | 13 +++++++------ src/solprop/backends/julia/_backend.py | 27 ++++++++++++++++++++++++++ 5 files changed, 61 insertions(+), 29 deletions(-) diff --git a/julia/src/adams.jl b/julia/src/adams.jl index ef8e68544..b90b5ac1d 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -145,6 +145,7 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} mask = c.norm_mask # The predictor, the flow and its moments, and the state's norm for the scale. active = c.mask + none, nil, h = zero(T), zero(C), T(step) squared = @section :adams_predict reduce_each(+, zero(T), c, size(y)...; heavy=true) do f, m @inbounds begin # Outside the band the state, the history and the source are exactly zero, @@ -152,7 +153,7 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} if !active[f] lab[f, m] = 0 compensated && (endpoint[f, m] = 0; error[f, m] = 0) - return zero(T) + return none end x = ComplexF64(step * linear[f, m]) if phi !== nothing @@ -163,12 +164,12 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} end values = phi_values(x, Val(N)) forward[f, m, 1] = values[1] - predicted = zero(C) + predicted = nil for k in 1:N - moment = C(values[k+1] / RECIP_FACTORIAL[k]) + moment = oftype(nil, values[k+1] / RECIP_FACTORIAL[k]) moments[f, m, k] = moment if k <= order - weighted = zero(C) + weighted = nil for j in 1:order weighted += predictor[j, k] * store[f, m, slots[j]] end @@ -176,20 +177,20 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} end end if compensated - correction = zero(C) + correction = nil for j in 1:N-1 slot = slots[j] - value = C(exp(spans[j] * x)) * (rates[f, m, slot] - C(x / step)) * states[f, m, slot] + value = oftype(nil, exp(spans[j] * x)) * (rates[f, m, slot] - oftype(nil, x / step)) * states[f, m, slot] carried[f, m, j] = value j <= order && (correction += cpredictor[j] * value) end predicted += correction error[f, m] = adams_rate(linear, phi, weights, f, m) end - value = C(values[1]) * y[f, m] + T(step) * predicted + value = oftype(nil, values[1]) * y[f, m] + h * predicted lab[f, m] = value - compensated && (endpoint[f, m] = (error[f, m] - C(x / step)) * value) - mask[f] ? abs2(y[f, m]) : zero(T) + compensated && (endpoint[f, m] = (error[f, m] - oftype(nil, x / step)) * value) + mask[f] ? abs2(y[f, m]) : none end end w.path === nothing || material_stage!(engine, 7) @@ -203,7 +204,7 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} candidate[f, m] = 0 return zero3 end - corrected = zero(C) + corrected = nil for k in 1:N weighted = corrector[1, k] * source[f, m] for j in 2:N @@ -218,7 +219,7 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} end corrected += correction end - candidate[f, m] = forward[f, m, 1] * y[f, m] + T(step) * corrected + candidate[f, m] = forward[f, m, 1] * y[f, m] + h * corrected result = zero3 if mask[f] scale = relative * weight[f] + absolute @@ -227,7 +228,7 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} for j in 2:N difference += defects[row, j] * store[f, m, slots[j-1]] end - polynomial = zero(C) + polynomial = nil for k in 1:N polynomial += defects[row, N+k] * moments[f, m, k] end @@ -239,7 +240,7 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} end defect += correction end - defect *= T(step) + defect *= h score = scale == 0 && defect == 0 ? zero(T) : abs2(defect / scale) result = Base.setindex(result, score, row) end diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 7b7b56f51..d1015a2fc 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -110,11 +110,12 @@ function weighted_norm(engine, error, magnitude) T = real_type(engine) (; weights, norm_mask) = c relative, absolute = T(c.rtol) * magnitude, T(c.atol) - residual = reduce_each(+, zero(T), c, size(error)...) do f, m + nothing_ = zero(T) + residual = reduce_each(+, nothing_, c, size(error)...) do f, m @inbounds begin scale = relative * weights[f] + absolute value = error[f, m] - norm_mask[f] && !(scale == 0 && value == 0) ? abs2(value / scale) : zero(T) + norm_mask[f] && !(scale == 0 && value == 0) ? abs2(value / scale) : nothing_ end end Float64(sqrt(residual)) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 1fadb9556..eadfe5ee2 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -60,9 +60,9 @@ function analytic_signal!(analytic, nodes, forward, inverse, c, count) forward * analytic # The unnormalised inverse's 1/nt is folded into the one-sided spectral factor. T = real(eltype(analytic)) - one, two, half = inv(T(nt)), 2 / T(nt), nt ÷ 2 + one, two, half, none = inv(T(nt)), 2 / T(nt), nt ÷ 2, zero(T) each!(c, nt, chunk) do f, m - @inbounds analytic[f, m] *= (f == 1 || f == half + 1) ? one : f <= half ? two : zero(T) + @inbounds analytic[f, m] *= (f == 1 || f == half + 1) ? one : f <= half ? two : none end inverse * analytic nothing @@ -198,6 +198,7 @@ function plasma_current!(p, nodes, c, count) charge, potential = T(p.parameters[6]), T(p.parameters[7]) density, initial = T(p.parameters[8]), T(p.parameters[9]) nt = size(nodes, 1) + none, nan = zero(T), T(NaN) each_column!(c, count) do node peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args) # With exactly zero rates and no initial electrons both currents vanish. @@ -208,9 +209,9 @@ function plasma_current!(p, nodes, c, count) end return nothing end - previous, value = T(NaN), zero(T) + previous, value = nan, none @inbounds for t in 1:nt - exposure = floor ? max(fraction[t, node], zero(T)) : fraction[t, node] + exposure = floor ? max(fraction[t, node], none) : fraction[t, node] # An unchanged prefix gives the same fraction: the zero-rate head and the # constant tail cost no exponential. No threshold, no approximation. if exposure != previous @@ -225,7 +226,7 @@ function plasma_current!(p, nodes, c, count) field = nodes[t, node] squared = field * field loss = rate[t, node] > 0 && squared > 0 ? - (potential * rate[t, node] * (1 - fraction[t, node]) / squared) * field : zero(T) + (potential * rate[t, node] * (1 - fraction[t, node]) / squared) * field : none total = density * (current[t, node] + loss) gated[t, node] = window[t] * total edge[t, node] = derivative[t] * total @@ -269,10 +270,11 @@ function population_parts!(p, nodes, c, first, count) floor, args = p.floor, rate_arguments(p) initial = T(p.parameters[9]) nt, reach = size(nodes, 1), 2 * (length(taps) - 1) + none = zero(T) each_column!(c, count) do node peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args) - dip = rise = paid = early = largest = zero(T) - before = product_before = start = zero(T) + dip = rise = paid = early = largest = none + before = product_before = start = none @inbounds for t in 1:nt exposure = fraction[t, node] if t > 1 @@ -280,7 +282,7 @@ function population_parts!(p, nodes, c, first, count) rise = max(rise, exposure - before) end before = exposure - value = 1 - (1 - initial) * exp(-(floor ? max(exposure, zero(T)) : exposure)) + value = 1 - (1 - initial) * exp(-(floor ? max(exposure, none) : exposure)) fraction[t, node] = value product = rate[t, node] * (1 - value) if t == 1 diff --git a/julia/src/rk4.jl b/julia/src/rk4.jl index b91c37464..90840fc17 100644 --- a/julia/src/rk4.jl +++ b/julia/src/rk4.jl @@ -12,6 +12,7 @@ function rk4!(engine, dz::Float64, key::Float64) mask = c.norm_mask h, half, third, sixth = T(dz), T(dz / 2), T(dz / 3), T(dz / 6) free_propagators!(engine, key / 2) + none = zero(T) source!(engine, y) each!(c, size(y)...) do f, m @inbounds begin @@ -24,7 +25,7 @@ function rk4!(engine, dz::Float64, key::Float64) end end source!(engine, lab) - lower = reduce_each(+, zero(T), c, size(y)...) do f, m + lower = reduce_each(+, none, c, size(y)...) do f, m @inbounds begin slope = source[f, m] difference = slope - error[f, m] @@ -32,26 +33,26 @@ function rk4!(engine, dz::Float64, key::Float64) error[f, m] = slope candidate[f, m] += third * slope lab[f, m] = y[f, m] + half * slope - mask[f] ? abs2(difference) : zero(T) + mask[f] ? abs2(difference) : none end end source!(engine, lab) - upper = reduce_each(+, zero(T), c, size(y)...) do f, m + upper = reduce_each(+, none, c, size(y)...) do f, m @inbounds begin slope = source[f, m] difference = slope - error[f, m] error[f, m] = difference candidate[f, m] += third * slope lab[f, m] = forward[f, m, 1] * (y[f, m] + h * slope) - mask[f] ? abs2(difference) : zero(T) + mask[f] ? abs2(difference) : none end end source!(engine, lab) - squared = reduce_each(+, zero(T), c, size(y)...) do f, m + squared = reduce_each(+, none, c, size(y)...) do f, m @inbounds begin new = forward[f, m, 1] * candidate[f, m] + sixth * source[f, m] candidate[f, m] = new - mask[f] ? abs2(new) : zero(T) + mask[f] ? abs2(new) : none end end (Float64(squared), lower > 0 ? 2sqrt(Float64(upper) / Float64(lower)) : NaN) diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 32c8c6c2c..5f18deff9 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -455,6 +455,7 @@ def __init__( self._recycle = _responses_recycle(problem) self._alarm = math.nan self._alarm_reported = False + self._host_blas = _hold_host_blas() if isinstance(problem.stepper.integrator, LowStorageRungeKutta): from solprop.backends.low_storage import LowStorageMarch # noqa: PLC0415 @@ -907,12 +908,38 @@ def memory_ledger(self) -> dict[str, int]: def close(self) -> None: """Release this engine's Julia references; repeated calls are harmless.""" + if self._host_blas is not None: + self._host_blas.restore_original_limits() + self._host_blas = None self._state = None self._engine = None self._closed = True self._rows.clear() +def _hold_host_blas() -> object | None: + """Hold every host BLAS pool to one thread while the engine lives, as native does. + + NumPy's OpenBLAS spins after each small host product (the transverse edge's + tables, the planes' statistics) on the cores the engine's pool waits on: on eight + Xeon cores a radial filament's window took 4.26 s with its eight threads and 1.07 s + with one. The lease is solprop's (``acquire_host_blas``), shared with native's. + + Returns + ------- + object or None + The lease, or None when no controllable BLAS is loaded. + """ + import threadpoolctl # noqa: PLC0415 - loaded with the engine only + + from solprop._process import acquire_host_blas # noqa: PLC0415 + + libraries = threadpoolctl.ThreadpoolController().select(user_api="blas") + if not libraries.lib_controllers: + return None + return acquire_host_blas(libraries.lib_controllers, 1) + + def _splits(problem: KernelProblem) -> bool: """Return whether accepted steps apply the split-step temporal collar.""" response = problem.responses From 5d8de465a66aa3550b0e9b9b95f7d2a420102b4a Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 15:35:19 +0000 Subject: [PATCH 009/107] Julia: edge energies in the engine, a GPU-safety check, tests [skip ci] The transverse edge's node and column energies are the engine's sums; the face tables act on the short vectors. SOLPROP_JULIA_CHECK refuses a kernel body capturing a type, box or union on any device, so CPU runs catch what a GPU would refuse. tests/backends/test_julia.py runs seven focus windows against numpy_ref: the same steps and the field to 1e-10. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 6 +- julia/src/adams.jl | 2 +- julia/src/launch.jl | 18 +++- julia/src/observe.jl | 57 ++++++++++++ src/solprop/backends/julia/_backend.py | 61 +++++++++++++ tests/backends/test_julia.py | 118 +++++++++++++++++++++++++ 6 files changed, 259 insertions(+), 3 deletions(-) create mode 100644 tests/backends/test_julia.py diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 65b7435f2..e410dcd7b 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -47,7 +47,11 @@ include("observe.jl") real_type(engine) = real(eltype(engine.work.y)) # Read at load, not at precompilation: a constant would be baked into the cache. -__init__() = (TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "1"; nothing) +function __init__() + TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "1" + CHECK[] = get(ENV, "SOLPROP_JULIA_CHECK", "0") == "1" + nothing +end """Read the shared settings and route to the modal or the free-space engine.""" function create(input) diff --git a/julia/src/adams.jl b/julia/src/adams.jl index b90b5ac1d..10117fc9e 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -241,7 +241,7 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} defect += correction end defect *= h - score = scale == 0 && defect == 0 ? zero(T) : abs2(defect / scale) + score = scale == 0 && defect == 0 ? none : abs2(defect / scale) result = Base.setindex(result, score, row) end end diff --git a/julia/src/launch.jl b/julia/src/launch.jl index d6223ffe3..916759e27 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -37,8 +37,21 @@ whose threads wait spinning: a pass between serial work costs 2.2 us on four Xeo cores where a spawned task costs 10 and `Threads.@threads` 110 (10240 x 4; 13, 49 and 147 us over 1728 x 128). On a GPU each sample is a thread. """ -@inline each!(f::F, c, nt::Integer, nm::Integer; heavy=false) where {F} = +@inline function each!(f::F, c, nt::Integer, nm::Integer; heavy=false) where {F} + CHECK[] && check_body(F) each_on!(f, c.backend, c.tasks, Int(nt), Int(nm), heavy) +end + +# SOLPROP_JULIA_CHECK=1: refuse a body a GPU kernel could not take, on any device. A +# captured type, box or union is found on a CPU run instead of on the first GPU one. +const CHECK = Ref(false) +function check_body(::Type{F}) where {F} + for T in fieldtypes(F) + (T <: Type || T === Core.Box || T isa Union || !isconcretetype(T)) && + throw(ArgumentError("kernel body $F captures $T, which a GPU kernel cannot take")) + (T <: Function || T <: Tuple || T <: NamedTuple) && check_body(T) + end +end function each_on!(f::F, ::KA.CPU, tasks, nt, nm, heavy) where {F} pieces, rows = tiling(tasks, nt, nm, heavy) @@ -84,6 +97,7 @@ end """Call `f(m)` for each of `nm` columns, whose body runs sequentially down one.""" function each_column!(f::F, c, nm::Integer) where {F} + CHECK[] && check_body(F) if oncpu(c) @batch for m in 1:Int(nm) @inline f(m) @@ -100,6 +114,7 @@ Each task (CPU) or thread (GPU) owns a block of rows, so no two write one sum. """ function rowsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} nt, nm = Int(nt), Int(nm) + CHECK[] && check_body(F) if oncpu(c) rows = max(256, cld(nt, c.tasks)) @batch for b in 1:cld(nt, rows) @@ -129,6 +144,7 @@ reduction tree's (GPU), and differs with the width (SEP 25 bounds it, not bits). """ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=false) where {F,O} nt, nm = Int(nt), Int(nm) + CHECK[] && check_body(F) if oncpu(c) pieces, rows = tiling(c.tasks, nt, nm, heavy) partials = fill(neutral, pieces * nm) diff --git a/julia/src/observe.jl b/julia/src/observe.jl index 905232a41..a6b01fc59 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -100,3 +100,60 @@ function occupancy(engine) end vec(sum(Array{Float64}(Array(histogram)); dims=2)) end + +# --- the transverse edge (SEP 44): per-node and per-column energies ----------------- + +"""Set `out[m]` to the sum over `t` of `f(t, m)`: one column's reduction each.""" +function colsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} + each_column!(c, nm) do m + total = zero(eltype(out)) + @inbounds for t in 1:nt + total += f(t, m) + end + @inbounds out[m] = total + nothing + end +end + +"""Each spectral column's energy, `sum |E|^2` over frequency.""" +function column_energy(engine) + y = engine.work.y + out = dzeros(engine.config, real_type(engine), size(y, 2)) + colsum!(engine.config, out, size(y)...) do f, m + @inbounds abs2(y[f, m]) + end + Vector{Float64}(Array(out)) +end + +"""Each physical node's energy: rows `rows` of the radial synthesis, or every node of +a Cartesian grid through the transverse inverse transform; zero elsewhere.""" +function node_energy(engine, inverse, rows) + c, w = engine.config, engine.work + y = w.y + T = real_type(engine) + nodes = zeros(Float64, size(y, 2)) + if c.free + physical = w.physical + copyto!(physical, y) + transverse!(physical, w.spatial_inverse, c) + scale = inv(T(size(y, 2)))^2 + out = dzeros(c, T, size(y, 2)) + colsum!(c, out, size(y)...) do f, m + @inbounds abs2(physical[f, m]) * scale + end + all = Vector{Float64}(Array(out)) + selected = Vector{Int}(rows) .+ 1 + nodes[selected] .= all[selected] + return nodes + end + selected = Vector{Int}(rows) .+ 1 + matrix = upload(c, T.(permutedims(Matrix{Float64}(inverse)[selected, :]))) + synthesised = dzeros(c, Complex{T}, size(y, 1), length(selected)) + mul!(synthesised, y, matrix) + out = dzeros(c, T, length(selected)) + colsum!(c, out, size(synthesised)...) do f, m + @inbounds abs2(synthesised[f, m]) + end + nodes[selected] .= Array(out) + nodes +end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 5f18deff9..acc263950 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -30,6 +30,7 @@ from solprop.grid import TimeGrid from solprop.modes.protocol import Mode from solprop.monitor import BoundaryEnergies, BoundaryMonitor +from solprop.transverse_monitor import TransverseEdge, _EdgeReading from solprop.noise import NoiseRealisation from solprop.output.schema import SavedPlane from solprop.profiles import ZProfile @@ -707,6 +708,66 @@ def _bind_monitor(self, monitor: BoundaryMonitor | None) -> None: None if crossing is None else np.asarray(crossing.buckets), ) + def _edge_reading( + self, + state: object, + edge: TransverseEdge, + *, + faces: bool = True, + current: bool = False, + full: bool = False, + ) -> _EdgeReading: + """Read the transverse edge from the engine's node and column energies. + + The state-sized sums are the engine's; the face tables act on the short + vectors here. A collar's strip and inward current keep the host reduction. + + Parameters + ---------- + state : object + The backend's state handle. + edge : solprop.transverse_monitor.TransverseEdge + The run's edge. + faces : bool, optional + Whether the nodes, the columns and any collar's strip are wanted. + current : bool, optional + Whether a collar's inward current is wanted. + full : bool, optional + Whether every node is wanted, not only the rows a read uses. + + Returns + ------- + solprop.transverse_monitor._EdgeReading + The reading. + """ + reduction = edge.reduction + if current or (faces and reduction.lines): + return super()._edge_reading( + state, edge, faces=faces, current=current, full=full + ) + if not faces: + return _EdgeReading() + tables = reduction.tables + count = self._problem.shape[1] + rows = np.arange(count) if full or self._problem.transform.kind == "free" else ( + np.asarray(tables.rows) + ) + inverse = reduction.synthesis() + nodes = np.asarray( + call_julia( + self._jl.node_energy, + self._engine, + None if inverse is None else np.asarray(inverse), + np.asarray(rows, dtype=np.int64), + ) + ) + return _EdgeReading( + faces=tables.faces @ nodes, + clip=tables.clip @ nodes if full else None, + totals=tables.totals @ nodes if full else None, + columns=np.asarray(call_julia(self._jl.column_energy, self._engine)), + ) + def _boundary_energies(self, state: object) -> BoundaryEnergies: """Read the monitor's energies from the engine's power, not a state copy. diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py new file mode 100644 index 000000000..e65ae04aa --- /dev/null +++ b/tests/backends/test_julia.py @@ -0,0 +1,118 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The Julia backend experiment against the NumPy oracle, on short benchmark windows. + +Optional: skipped unless ``solprop[julia]`` is installed and ``julia/bootstrap.py`` has +prepared the runtime. ``SOLPROP_JULIA_DEVICE=cuda`` runs the same tests on an NVIDIA GPU +(``pytest -m gpu``). Every kernel body is checked to be one a GPU could take +(``SOLPROP_JULIA_CHECK``), so that a CPU run catches what would fail on a device. +""" + +import importlib.util +import os + +import numpy as np +import pytest + +from benchmarks.builders import build +from benchmarks.registry import CASES +from solprop.backends import select +from solprop.exceptions import BackendError + +os.environ.setdefault("SOLPROP_JULIA_CHECK", "1") +DEVICE = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") +pytestmark = [pytest.mark.medium] + ([pytest.mark.gpu] if DEVICE != "cpu" else []) + + +@pytest.fixture(scope="module") +def runtime(): + """Start the runtime once per worker process, or skip without one.""" + if importlib.util.find_spec("juliacall") is None: + pytest.skip("solprop[julia] is not installed") + from solprop.backends.julia._runtime import runtime as start # noqa: PLC0415 + + try: + return start() + except BackendError as exc: + pytest.skip(f"the Julia runtime is not prepared: {exc}") + + +# (case, stepper, fraction): each a few steps of a focus route (docs/guide/performance/ +# julia.md). The fractions keep the NumPy oracle to seconds. +WINDOWS = [ + ("rdw", "rk", 0.002), + ("rdw", "default", 0.002), + ("argon_blueshift", "default", 0.002), + ("h2_raman_6ps", "default", 0.0005), + ("radial_filament_256", "default", 0.002), + ("line", "default", 0.005), + ("kerr_beam_192", "default", 1.0), +] + + +def _run(name, configuration): + """Propagate the configured window on one backend; return the field and steps.""" + simulation = build(configuration | {"backend": name}) + problem = simulation.translate() + engine = select( + name, + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(float(configuration["stop"])) + observation = engine.observe(field=True) + steps = (observation.n_steps, observation.n_rejected) + engine.close() + return observation.field, steps + + +# The Cartesian beam's fused silica is evaluated past Malitson's range, by design of the +# benchmark case; the warning says so and is not this test's subject. +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS) +def test_julia_matches_the_reference(runtime, case, stepper, fraction): + """Same steps, and the same field to rounding, as numpy_ref on the same contract.""" + del runtime + configuration = CASES[case].configuration( + stepper, 2, "julia", fraction=fraction, noise="none" + ) + field, steps = _run("julia", configuration) + reference, reference_steps = _run("numpy_ref", configuration) + assert steps == reference_steps + # Matched discrete methods on one step sequence: the fields differ by the rounding + # of their transforms and sums, which the native/julia A/B measures at <= 1e-13 + # over these windows; 1e-10 leaves three orders for longer accumulation and is + # still far below the controller's 1e-6 relative tolerance. + scale = float(np.linalg.norm(reference)) + assert scale > 0 + assert float(np.linalg.norm(field - reference)) <= 1e-10 * scale + + +def test_julia_refuses_single_precision(runtime): + """Single precision is not admitted until its error budgets are qualified.""" + del runtime + configuration = CASES["rdw"].configuration("rk", 1, "julia", fraction=0.001) + simulation = build(configuration | {"precision": "single", "backend": "numpy_ref"}) + problem = simulation.translate() + with pytest.raises(BackendError, match="single precision"): + select("julia", problem, grid=simulation.grid, modes=simulation.modes) + + +def test_julia_reports_its_engine(runtime): + """Metadata names the runtime and the sources; the ledger counts owned arrays.""" + del runtime + configuration = CASES["rdw"].configuration("rk", 1, "julia", fraction=0.001) + simulation = build(configuration | {"noise": "none"}) + problem = simulation.translate() + engine = select("julia", problem, grid=simulation.grid, modes=simulation.modes) + metadata = engine.metadata() + assert metadata["experimental"] is True + assert len(metadata["julia_source_digest"]) == 64 + assert metadata["device"].startswith(DEVICE) + ledger = engine.memory_ledger() + assert ledger["work.y"] == 16 * problem.shape[1] * problem.shape[3] + engine.close() From be38ebce9ef0cc05b6d024a13a28ad9c4e0c9a24 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 15:40:50 +0000 Subject: [PATCH 010/107] Julia: native's phi-function evaluation; edge rows bound once [skip ci] The series stops at a quarter ulp and multiplies by the divisors' reciprocals, the large-argument recurrence uses one reciprocal: the radial Adams predictor 0.16 s -> 0.10 s. A radial read's synthesis rows are uploaded once, not at every read. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 1 + julia/src/adams.jl | 33 ++++++++++++++++------- julia/src/free.jl | 2 +- julia/src/modal.jl | 2 +- julia/src/observe.jl | 37 ++++++++++++++++---------- src/solprop/backends/julia/_backend.py | 11 +++++--- 6 files changed, 57 insertions(+), 29 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index e410dcd7b..3e514be6c 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -151,6 +151,7 @@ const rk4_b = rk4! const configure_stages_b = configure_stages! const load_b = load! const bind_monitor_b = bind_monitor! +const bind_edge_b = bind_edge! const trial_b = trial! const commit_b = commit! const evaluate_b = evaluate! diff --git a/julia/src/adams.jl b/julia/src/adams.jl index 10117fc9e..d23553c3e 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -7,29 +7,44 @@ const RECIP_FACTORIAL = ntuple(k -> 1.0 / factorial(k - 1), 10) +const RECIP_INTEGER = ntuple(k -> 1.0 / k, 40) + """`phi_0(x) .. phi_N(x)` by a shifted series and scaling and squaring. Evaluated in binary64 at either precision: the flow and its moments are rounded once -to the state's precision (SEP 33). +to the state's precision (SEP 33). Native's `adams_phi` (adams_phi.hpp) is the model: +past |x| = 3 the recurrence from `exp(x)` with one reciprocal of x; below it the series +of `phi_N(y)`, `y = x / 2^s` with |y| <= 1/2, multiplied by the divisors' reciprocals +and stopped once a term is under a quarter ulp of the sum (each later one is smaller +by |y| / (m + N) <= 1/2), then raised back by `s` squarings. """ @inline function phi_values(x::ComplexF64, ::Val{N}) where {N} - if abs(x) > 3.0 - out = ntuple(_ -> zero(ComplexF64), Val(N + 1)) + magnitude = abs(x) + out = ntuple(_ -> zero(ComplexF64), Val(N + 1)) + if magnitude > 3.0 + inverse = inv(x) out = Base.setindex(out, exp(x), 1) for k in 1:N - out = Base.setindex(out, (out[k] - RECIP_FACTORIAL[k]) / x, k + 1) + out = Base.setindex(out, (out[k] - RECIP_FACTORIAL[k]) * inverse, k + 1) end return out end - levels = abs(x) <= 0.5 ? 0 : ceil(Int, log2(abs(x) / 0.5)) - y = x / 2.0^levels + levels, scale = 0, 1.0 + reduced = magnitude + while reduced > 0.5 + levels += 1 + scale *= 0.5 + reduced *= 0.5 + end + y = scale * x term = complex(RECIP_FACTORIAL[N+1]) total = term + stop = (0.25 * eps(Float64))^2 for m in 1:23 - term = term * y / (m + N) + term = term * y * RECIP_INTEGER[m+N] total += term + abs2(term) <= stop * abs2(total) && break end - out = ntuple(_ -> zero(ComplexF64), Val(N + 1)) out = Base.setindex(out, total, N + 1) for k in N-1:-1:1 out = Base.setindex(out, RECIP_FACTORIAL[k+1] + y * out[k+2], k + 1) @@ -43,7 +58,7 @@ to the state's precision (SEP 33). for j in 1:k value += old[j+1] * RECIP_FACTORIAL[k-j+1] end - out = Base.setindex(out, value / 2.0^k, k + 1) + out = Base.setindex(out, value * 0.5^k, k + 1) end end out diff --git a/julia/src/free.jl b/julia/src/free.jl index ce0e84cd9..b8bb6221b 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -43,7 +43,7 @@ function create_free(c, host) coarse, coarse_spec = dzeros(c, R, nc, chunk), dzeros(c, C, nw, chunk) planes = (threads=c.transverse_fft_threads, batch=1) work = ( - adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), + adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), plasma=plasma_workspace(c, host, nt, chunk, chunk, nm), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), diff --git a/julia/src/modal.jl b/julia/src/modal.jl index a0d028d34..e70f4d8e0 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -58,7 +58,7 @@ function create_modal(c, host) band = dzeros(c, C, nw, nm) work = ( adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), - monitor=monitor_workspace(c, nw, nm, c.nc), + monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), diff --git a/julia/src/observe.jl b/julia/src/observe.jl index a6b01fc59..d43cc647c 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -125,35 +125,44 @@ function column_energy(engine) Vector{Float64}(Array(out)) end -"""Each physical node's energy: rows `rows` of the radial synthesis, or every node of -a Cartesian grid through the transverse inverse transform; zero elsewhere.""" -function node_energy(engine, inverse, rows) +"""Hold a radial read's synthesis rows (0-based `rows` of `inverse`) for `node_energy`.""" +function bind_edge!(engine, inverse, rows) + c, y = engine.config, engine.work.y + T = real_type(engine) + selected = Vector{Int}(rows) .+ 1 + matrix = c.free ? nothing : upload(c, T.(permutedims(Matrix{Float64}(inverse)[selected, :]))) + engine.work.edge[] = (selected=selected, matrix=matrix, + synthesised=c.free ? nothing : dzeros(c, Complex{T}, size(y, 1), length(selected)), + energy=dzeros(c, T, c.free ? size(y, 2) : length(selected))) + nothing +end + +"""Each physical node's energy at the bound rows (`bind_edge!`), zero elsewhere: the +radial synthesis's rows, or every node of a Cartesian grid through the transverse +inverse transform.""" +function node_energy(engine) c, w = engine.config, engine.work - y = w.y + y, edge = w.y, w.edge[] T = real_type(engine) nodes = zeros(Float64, size(y, 2)) + out = edge.energy if c.free physical = w.physical copyto!(physical, y) transverse!(physical, w.spatial_inverse, c) scale = inv(T(size(y, 2)))^2 - out = dzeros(c, T, size(y, 2)) colsum!(c, out, size(y)...) do f, m @inbounds abs2(physical[f, m]) * scale end - all = Vector{Float64}(Array(out)) - selected = Vector{Int}(rows) .+ 1 - nodes[selected] .= all[selected] + all = Array(out) + nodes[edge.selected] .= all[edge.selected] return nodes end - selected = Vector{Int}(rows) .+ 1 - matrix = upload(c, T.(permutedims(Matrix{Float64}(inverse)[selected, :]))) - synthesised = dzeros(c, Complex{T}, size(y, 1), length(selected)) - mul!(synthesised, y, matrix) - out = dzeros(c, T, length(selected)) + synthesised = edge.synthesised + mul!(synthesised, y, edge.matrix) colsum!(c, out, size(synthesised)...) do f, m @inbounds abs2(synthesised[f, m]) end - nodes[selected] .= Array(out) + nodes[edge.selected] .= Array(out) nodes end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index acc263950..1b8544bf2 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -457,6 +457,7 @@ def __init__( self._alarm = math.nan self._alarm_reported = False self._host_blas = _hold_host_blas() + self._edge_key: tuple[int, bool] | None = None if isinstance(problem.stepper.integrator, LowStorageRungeKutta): from solprop.backends.low_storage import LowStorageMarch # noqa: PLC0415 @@ -752,15 +753,17 @@ def _edge_reading( rows = np.arange(count) if full or self._problem.transform.kind == "free" else ( np.asarray(tables.rows) ) - inverse = reduction.synthesis() - nodes = np.asarray( + key = (id(reduction), bool(full)) + if self._edge_key != key: + inverse = reduction.synthesis() call_julia( - self._jl.node_energy, + self._jl.bind_edge_b, self._engine, None if inverse is None else np.asarray(inverse), np.asarray(rows, dtype=np.int64), ) - ) + self._edge_key = key + nodes = np.asarray(call_julia(self._jl.node_energy, self._engine)) return _EdgeReading( faces=tables.faces @ nodes, clip=tables.clip @ nodes if full else None, From cade2f10e7ff58389cc3b7db4d7587d129809de5 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 15:45:18 +0000 Subject: [PATCH 011/107] Julia: device-synchronised section timers; profile whole timed runs [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/profile.py | 90 ++++++++++++++++++++++----------------- julia/src/SolpropJulia.jl | 1 + julia/src/dopri.jl | 3 +- julia/src/launch.jl | 6 ++- julia/src/observe.jl | 8 ++-- 5 files changed, 63 insertions(+), 45 deletions(-) diff --git a/julia/profile.py b/julia/profile.py index db64d672b..048738674 100644 --- a/julia/profile.py +++ b/julia/profile.py @@ -1,30 +1,29 @@ # SPDX-FileCopyrightText: 2026 John C. Travers and contributors # SPDX-License-Identifier: GPL-3.0-or-later -"""Profile the Julia engine on one row of a benchmark plan. +"""Profile the Julia engine on rows of a benchmark plan, as the harness times them. -``python julia/profile.py PLAN.json ROW [FRACTION]`` builds the row's case for the -julia backend, warms it up, then samples Julia's stacks over a propagation to -``FRACTION`` of the row's stop (default 1) and prints the flat profile. Run it with -``SOLPROP_JULIA_THREADS=1``: Julia's sampling profiler crashes when Python owns more -threads. ``SOLPROP_JULIA_TIMING=1`` prints the engine's section timers instead, at -any width. +``python julia/profile.py PLAN.json ROW...`` builds each matching row's case for the +julia backend and times a complete run (``benchmarks.worker.timed_run``, observations +and the boundary monitor included) after a first, warming one. With +``SOLPROP_JULIA_TIMING=1`` it prints the engine's section timers, synchronised with the +device on a GPU; with ``SOLPROP_JULIA_PROFILE=1`` Julia's sampling profile instead, +which needs ``SOLPROP_JULIA_THREADS=1`` (it crashes when Python owns more threads). """ import json +import os import sys -import time from benchmarks.builders import build +from benchmarks.worker import timed_run from solprop.backends import select +from solprop.driver.run import field_retention -def main() -> None: - """Profile one plan row.""" - plan = json.loads(open(sys.argv[1], encoding="utf-8").read()) # noqa: PTH123, SIM115 - row = next(r for r in plan["rows"] if sys.argv[2] in r["id"]) +def profile(row: dict) -> None: + """Time one row's run twice and report the second.""" configuration = row["configuration"] | {"backend": "julia"} - fraction = float(sys.argv[3]) if len(sys.argv) > 3 else 1.0 # noqa: PLR2004 simulation = build(configuration) problem = simulation.translate() engine = select( @@ -34,35 +33,46 @@ def main() -> None: modes=simulation.modes, profiles=simulation.profiles, ) - stop = fraction * float(configuration["stop"]) - engine.set_initial(problem.initial.field0, None, z=problem.initial.z) - engine.propagate_to(0.5 * stop) - from juliacall import Main as jl # noqa: PLC0415 - after the runtime starts + retention = field_retention( + problem, simulation.settings.fields, simulation.settings.field_planes + ) + timed_run(simulation, problem, engine, retention, simulation._boundary_monitor()) # noqa: SLF001 + jl = engine._jl # noqa: SLF001 + sampling = os.environ.get("SOLPROP_JULIA_PROFILE") == "1" + if sampling: + from juliacall import Main # noqa: PLC0415 - after the runtime starts - timing = bool(engine._jl.timing_enabled()) # noqa: SLF001 - if timing: - engine._jl.clear_timings() # noqa: SLF001 - engine.set_initial(problem.initial.field0, None, z=problem.initial.z) - started = time.perf_counter() - engine.propagate_to(stop) - seconds = time.perf_counter() - started - times = engine._jl.timings() # noqa: SLF001 - for name in sorted(times, key=lambda n: -float(times[n])): - sys.stdout.write(f"{name:>20} {float(times[name]):9.4f} s\n") - sys.stdout.write(f"{row['id']}: {seconds:.3f} s to {stop:.3g} m\n") - return - jl.seval("using Profile; Profile.init(n=10^7, delay=0.0005)") - engine.set_initial(problem.initial.field0, None, z=problem.initial.z) - jl.seval("Profile.clear(); Profile.start_timer()") - started = time.perf_counter() - engine.propagate_to(stop) - seconds = time.perf_counter() - started - jl.seval("Profile.stop_timer()") - jl.seval( - "Profile.print(IOContext(stdout, :displaysize => (200, 220)); format=:flat, " - "sortedby=:count, mincount=20, noisefloor=1)" + Main.seval("using Profile; Profile.init(n=10^7, delay=0.0005)") + Main.seval("Profile.clear(); Profile.start_timer()") + jl.clear_timings() + record, _ = timed_run( + simulation, problem, engine, retention, simulation._boundary_monitor() # noqa: SLF001 + ) + if sampling: + Main.seval("Profile.stop_timer()") + Main.seval( + "Profile.print(IOContext(stdout, :displaysize => (200, 220)); format=:flat, " + "sortedby=:count, mincount=20, noisefloor=1)" + ) + times = jl.timings() + total = sum(float(times[name]) for name in times) + sys.stdout.write( + f"{row['id']}: {record['seconds']:.3f} s, {record['accepted']} steps, " + f"sections {total:.3f} s\n" ) - sys.stdout.write(f"\n{row['id']}: {seconds:.3f} s to {stop:.3g} m\n") + for name in sorted(times, key=lambda n: -float(times[n])): + sys.stdout.write(f" {name:>18} {float(times[name]):8.4f} s\n") + engine.close() + + +def main() -> None: + """Profile every row of the plan whose id contains one of the arguments.""" + plan = json.loads(open(sys.argv[1], encoding="utf-8").read()) # noqa: PTH123, SIM115 + for row in plan["rows"]: + if row["configuration"]["backend"] == "native" and any( + name in row["id"] for name in sys.argv[2:] + ): + profile(row) if __name__ == "__main__": diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 3e514be6c..e9226f46e 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -73,6 +73,7 @@ function create(input) cache_propagators=host.has("cache_propagators") ? host.flag("cache_propagators") : true, ) engine = c.free ? create_free(c, host) : create_modal(c, host) + oncpu(c) || (SYNCHRONIZE[] = () -> KA.synchronize(backend)) compile!(engine) engine end diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index d1015a2fc..60c2153be 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -122,7 +122,8 @@ function weighted_norm(engine, error, magnitude) end """Accept the candidate: the mask, the split-step collar, then the quadrature alarm.""" -function commit!(engine, dz::Float64, monitored::Bool=false) +commit!(engine, dz::Float64, monitored::Bool=false) = @section :commit commit_step!(engine, dz, monitored) +function commit_step!(engine, dz, monitored) c, w = engine.config, engine.work mask!(engine, w.candidate) if c.split_active diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 916759e27..fbed17b7e 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -229,14 +229,18 @@ function gemm!(C, A, B, alpha, beta, c) end # Section timers for development: SOLPROP_JULIA_TIMING=1 when the module loads. Off, -# `@section` is its expression alone. On a GPU the times are launch times only. +# `@section` costs one branch. const TIMING = Ref(false) const TIMES = Dict{Symbol,Float64}() +# A device's timed sections wait for its queue at both ends (`synchronize_all`). +const SYNCHRONIZE = Ref{Any}(() -> nothing) macro section(name, ex) quote if TIMING[] + SYNCHRONIZE[]() local started = time_ns() local result = $(esc(ex)) + SYNCHRONIZE[]() TIMES[$name] = get(TIMES, $name, 0.0) + (time_ns() - started) * 1e-9 result else diff --git a/julia/src/observe.jl b/julia/src/observe.jl index d43cc647c..c764e364f 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -5,7 +5,7 @@ # monitor's reductions, formed here so that only short vectors cross (SEP 21, ADR-057). """The accepted state, for the host: the engine's own array on a CPU in binary64.""" -host_state(engine) = host_view(engine.work.y) +host_state(engine) = @section :observe host_view(engine.work.y) host_candidate(engine) = host_view(engine.work.candidate) host_view(a::Matrix{ComplexF64}) = a host_view(a) = Matrix{ComplexF64}(Array(a)) @@ -48,7 +48,8 @@ function add_power!(power, samples, weights, first, count, c) end """`P(t)` of the accepted state on the coarse time axis: the monitor's `power`.""" -function state_power(engine) +state_power(engine) = @section :monitor monitor_power(engine) +function monitor_power(engine) c, w = engine.config, engine.work (; power, columns) = w.monitor fill!(power, 0) @@ -140,7 +141,8 @@ end """Each physical node's energy at the bound rows (`bind_edge!`), zero elsewhere: the radial synthesis's rows, or every node of a Cartesian grid through the transverse inverse transform.""" -function node_energy(engine) +node_energy(engine) = @section :edge edge_energy(engine) +function edge_energy(engine) c, w = engine.config, engine.work y, edge = w.y, w.edge[] T = real_type(engine) From 6615562f6bdd2c54d9de3458a9ffaa2b6ef63bd9 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 16:03:08 +0000 Subject: [PATCH 012/107] Julia: plasma a sample a thread on GPUs; warm every path at construction [skip ci] On a GPU the plasma's passes are a sample a thread and its two running integrals column-wise scans (SOLPROP_JULIA_PLASMA=samples takes the same path on a CPU). create() runs each path once on the zero state, so a GPU's kernels compile at construction rather than in the timed run. A branch-free log for later vectorised passes (vmath.jl, not yet used). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 32 +++++++++++++++++++ julia/src/responses.jl | 65 +++++++++++++++++++++++++++++++++++++-- julia/src/vmath.jl | 51 ++++++++++++++++++++++++++++++ 3 files changed, 146 insertions(+), 2 deletions(-) create mode 100644 julia/src/vmath.jl diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index e9226f46e..13de580c7 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -50,6 +50,7 @@ real_type(engine) = real(eltype(engine.work.y)) function __init__() TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "1" CHECK[] = get(ENV, "SOLPROP_JULIA_CHECK", "0") == "1" + SAMPLE_PLASMA[] = get(ENV, "SOLPROP_JULIA_PLASMA", "columns") == "samples" nothing end @@ -75,9 +76,40 @@ function create(input) engine = c.free ? create_free(c, host) : create_modal(c, host) oncpu(c) || (SYNCHRONIZE[] = () -> KA.synchronize(backend)) compile!(engine) + warm!(engine) engine end +"""Run each path once on the zero state, then forget it: a GPU's kernels compile at +their first launch, which `compile!`'s inference does not reach.""" +function warm!(engine) + c, w = engine.config, engine.work + a = w.adams + if c.low_storage + rk4!(engine, 1e-12, 1e-12) + elseif a !== nothing + adams_start!(engine) + for n in 1:size(a.moments, 3) + a.sizes .= (min(n, size(a.moments, 3) - 1), n, 1) + adams_trial_width!(engine, 1e-12, Val(n)) + end + adams_accept!(engine, 1) + fill!(a.sizes, 0) + else + trial!(engine, 1e-12) + end + commit!(engine, 1e-12, true) + state_power(engine) + occupancy(engine) + host_state(engine) + for buffer in (w.y, w.candidate, w.lab, w.source, w.error, w.stages) + fill!(buffer, 0) + end + engine.fsal_valid, engine.calls, engine.propagator_dz = false, 0, NaN + TIMING[] && empty!(TIMES) + nothing +end + """Compile every entry point the march calls for this engine's types, now. Construction is timed apart from propagation; without this, a run's first step and diff --git a/julia/src/responses.jl b/julia/src/responses.jl index eadfe5ee2..615ed64f3 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -189,8 +189,69 @@ end peak end -"""The plasma current of each node of a chunk, gated by the window and the collar.""" -function plasma_current!(p, nodes, c, count) +"""The plasma current of each node of a chunk, gated by the window and the collar. + +On a CPU each node's column is one task, scanned in order with its exact zero support +skipped. On a GPU, where a column a thread leaves most of the device idle, every +pass is a sample a thread and the two running integrals are column-wise scans: their +sums are reassociated, which SEP 25 permits and the tests bound, as native's +two-level device scans do. +""" +plasma_current!(p, nodes, c, count) = + oncpu(c) && !SAMPLE_PLASMA[] ? plasma_columns!(p, nodes, c, count) : + plasma_samples!(p, nodes, c, count) +# SOLPROP_JULIA_PLASMA=samples takes the GPU's path on a CPU too. +const SAMPLE_PLASMA = Ref(false) + +"""`out` = the running trapezoid of the FIR-filtered `values`, every column at once.""" +function integrate_samples!(out, values, scratch, taps, dt, c, count) + nt = size(values, 1) + each!(c, nt, count) do t, n + @inbounds scratch[t, n] = filtered(values, t, n, taps) + end + half = dt / 2 + each!(c, nt, count) do t, n + @inbounds out[t, n] = t == 1 ? zero(dt) : half * (scratch[t, n] + scratch[t-1, n]) + end + AK.accumulate!(+, @view(out[:, 1:count]); dims=1, init=zero(dt), backend=c.backend) + nothing +end + +function plasma_samples!(p, nodes, c, count) + T = typeof(p.dt) + (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative) = p + window, floor = c.window, p.floor + args = rate_arguments(p) + charge, potential = T(p.parameters[6]), T(p.parameters[7]) + density, initial = T(p.parameters[8]), T(p.parameters[9]) + nt, none = size(nodes, 1), zero(T) + each!(c, nt, count) do t, n + @inbounds rate[t, n] = rate_value(nodes[t, n], args...) + end + integrate_samples!(fraction, rate, current, taps, dt, c, count) + each!(c, nt, count) do t, n + @inbounds begin + exposure = floor ? max(fraction[t, n], none) : fraction[t, n] + value = 1 - (1 - initial) * exp(-exposure) + fraction[t, n] = value + integrand[t, n] = value * charge * nodes[t, n] + end + end + integrate_samples!(current, integrand, gated, taps, dt, c, count) + each!(c, nt, count) do t, n + @inbounds begin + field = nodes[t, n] + squared = field * field + loss = rate[t, n] > 0 && squared > 0 ? + (potential * rate[t, n] * (1 - fraction[t, n]) / squared) * field : none + total = density * (current[t, n] + loss) + gated[t, n] = window[t] * total + edge[t, n] = derivative[t] * total + end + end +end + +function plasma_columns!(p, nodes, c, count) T = typeof(p.dt) (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative) = p window, floor = c.window, p.floor diff --git a/julia/src/vmath.jl b/julia/src/vmath.jl new file mode 100644 index 000000000..008abc580 --- /dev/null +++ b/julia/src/vmath.jl @@ -0,0 +1,51 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Branch-free exp and log in binary64, which a SIMD loop vectorises: Base's look up +# tables and branch, so a loop of them runs one lane at a time. Native calls SLEEF's +# 1-ulp vector functions for the same reason (native/include/solprop_native/vmath.hpp). +# Both here are within about one ulp (julia/test/runtests.jl checks it); binary32 and +# complex arguments keep Base's. + +const LN2_HI = 6.93147180369123816490e-01 +const LN2_LO = 1.90821492927058770002e-10 + +"""`exp(x)` by Cody-Waite reduction to |r| <= ln2/2 and its Taylor series to r^13.""" +@inline function vexp(x::Float64) + n = round(x * 1.4426950408889634) + r = muladd(-n, LN2_LO, muladd(-n, LN2_HI, x)) + # r^14/14! < 5e-18 at |r| = ln2/2: below half an ulp of the sum. + p = evalpoly(r, (1.0, 1.0, 1 / 2, 1 / 6, 1 / 24, 1 / 120, 1 / 720, 1 / 5040, 1 / 40320, + 1 / 362880, 1 / 3628800, 1 / 39916800, 1 / 479001600, 1 / 6227020800)) + # 2^n in two exact factors, so that a subnormal result keeps its bits. + k = unsafe_trunc(Int64, clamp(n, -2000.0, 2000.0)) + half = k >> 1 + scale1 = reinterpret(Float64, (clamp(half, -1022, 1023) + 1023) << 52) + scale2 = reinterpret(Float64, (clamp(k - half, -1022, 1023) + 1023) << 52) + value = p * scale1 * scale2 + value = ifelse(x > 709.782712893384, Inf, value) + value = ifelse(x < -745.1332191019412, 0.0, value) + ifelse(isnan(x), x, value) +end +@inline vexp(x) = exp(x) + +"""`log(x)` for positive normal `x` (fdlibm's e_log.c, without its branches).""" +@inline function vlog(x::Float64) + bits = reinterpret(UInt64, x) + e = Int64((bits >> 52) & 0x7ff) - 1023 + m = reinterpret(Float64, (bits & 0x000fffffffffffff) | 0x3ff0000000000000) + high = m > 1.4142135623730951 + m = ifelse(high, 0.5 * m, m) + k = Float64(e + high) + f = m - 1.0 + hfsq = 0.5 * f * f + s = f / (2.0 + f) + z = s * s + w = z * z + t1 = w * evalpoly(w, (3.999999999940941908e-01, 2.222219843214978396e-01, 1.531383769920937332e-01)) + t2 = z * evalpoly(w, (6.666666666666735130e-01, 2.857142874366239149e-01, + 1.818357216161805012e-01, 1.479819860511658591e-01)) + R = t2 + t1 + k * LN2_HI - ((hfsq - (s * (hfsq + R) + k * LN2_LO)) - f) +end +@inline vlog(x) = log(x) From 3e2290c0d65a115b67dcb2a14a6ef3a041d00f7f Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 17:12:28 +0000 Subject: [PATCH 013/107] Julia: fix the warm-up's out-of-range reads; warm the observers and the bridge [skip ci] The warm-up's Adams trials read the store through zero slots and its occupancy wrote bucket zero, both outside their arrays under @inbounds: intermittent wrong steps at four threads on four cores. Slots and buckets now start valid, every Adams buffer is cleared after the warm-up, and the tests run Julia with bounds checking. The edge, populations, occupancy and each bridge entry's conversions are warmed at construction: a run's first timed window now compiles 0.01-0.17 s instead of 0.6-3.5 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 19 +++++++++++---- julia/src/observe.jl | 3 ++- src/solprop/backends/julia/_backend.py | 32 ++++++++++++++++++++++++++ tests/backends/test_julia.py | 2 ++ 4 files changed, 51 insertions(+), 5 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 13de580c7..0c7453619 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -88,6 +88,9 @@ function warm!(engine) if c.low_storage rk4!(engine, 1e-12, 1e-12) elseif a !== nothing + # Valid history rows, so that no warm trial reads outside the store. + fill!(a.host.slots, 1) + copyto!(a.device.slots, a.host.slots) adams_start!(engine) for n in 1:size(a.moments, 3) a.sizes .= (min(n, size(a.moments, 3) - 1), n, 1) @@ -99,12 +102,20 @@ function warm!(engine) trial!(engine, 1e-12) end commit!(engine, 1e-12, true) + # The observers' paths too: the monitor, the edge (on a provisional binding), the + # occupancy and the populations. state_power(engine) - occupancy(engine) host_state(engine) - for buffer in (w.y, w.candidate, w.lab, w.source, w.error, w.stages) - fill!(buffer, 0) - end + occupancy(engine) + nm = size(w.y, 2) + bind_edge!(engine, c.free ? nothing : Matrix{Float64}(I, nm, nm), [0]) + node_energy(engine) + column_energy(engine) + w.edge[] = nothing + w.plasma === nothing || population_snapshot(engine, zeros(ComplexF64, size(w.y))) + buffers = (w.y, w.candidate, w.lab, w.source, w.error, w.stages, w.forward, w.inverse) + a === nothing || (buffers = (buffers..., a.store, a.states, a.rates, a.moments, a.carried, a.endpoint)) + foreach(buffer -> fill!(buffer, 0), buffers) engine.fsal_valid, engine.calls, engine.propagator_dz = false, 0, NaN TIMING[] && empty!(TIMES) nothing diff --git a/julia/src/observe.jl b/julia/src/observe.jl index c764e364f..9d1c477d3 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -34,7 +34,8 @@ function bind_monitor!(engine, columns, buckets) nothing end function monitor_workspace(c, nw, nm, nc) - (columns=dzeros(c, c.T, nm), buckets=dzeros(c, Int32, nw, nm), power=dzeros(c, c.T, nc), + # Bucket one until a crossing binds its own: an index the histogram always holds. + (columns=dzeros(c, c.T, nm), buckets=fill!(dzeros(c, Int32, nw, nm), Int32(1)), power=dzeros(c, c.T, nc), split=dzeros(c, c.T, nc), histogram=dzeros(c, c.T, 128, c.tasks)) end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 1b8544bf2..98d2ad94b 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -458,6 +458,7 @@ def __init__( self._alarm_reported = False self._host_blas = _hold_host_blas() self._edge_key: tuple[int, bool] | None = None + self._warm_bridge() if isinstance(problem.stepper.integrator, LowStorageRungeKutta): from solprop.backends.low_storage import LowStorageMarch # noqa: PLC0415 @@ -468,6 +469,37 @@ def __init__( self._adams = AdamsMarch(self, problem.stepper.integrator) + def _warm_bridge(self) -> None: + """Call each bridge entry the march reaches with the arguments it will pass. + + The engine compiled and ran its own paths at construction; what is left is + the bridge's per-function wrappers and argument conversions, which otherwise + compile inside a run's first boundary reading or edge read. + """ + _, n_modes, _, n_omega = self._problem.shape + jl, engine = self._jl, self._engine + # A crossing's bucket table is read-only, which is part of its bridge type. + buckets = np.zeros((n_modes, n_omega), dtype=np.uint8) + buckets.setflags(write=False) + for columns, table in ((None, None), (np.ones(n_modes), buckets)): + call_julia(jl.bind_monitor_b, engine, columns, table) + for name in ("state_power", "occupancy", "split_power", "column_energy"): + np.asarray(call_julia(getattr(jl, name), engine)) + free = self._problem.transform.kind == "free" + inverse = None if free else np.eye(n_modes) + call_julia(jl.bind_edge_b, engine, inverse, np.zeros(1, dtype=np.int64)) + call_julia(jl.node_energy, engine) + call_julia(jl.device_name, engine) + np.asarray(call_julia(jl.host_state, engine)) + if self._problem.flags.has_plasma: + call_julia( + jl.population_snapshot, + engine, + np.zeros((n_omega, n_modes), dtype=np.complex128), + ) + call_julia(jl.bind_monitor_b, engine, None, None) + self.metadata() + def _adams_state(self) -> Complex[np.ndarray, "n_batch n_modes n_pol n_omega"]: """Copy the resident state for rare host persistence and budget reports.""" return self._observed_field(self._require_state()) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index e65ae04aa..ec9d2e473 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -21,6 +21,8 @@ from solprop.exceptions import BackendError os.environ.setdefault("SOLPROP_JULIA_CHECK", "1") +# Bounds checked: an @inbounds index slip raises here instead of corrupting memory. +os.environ.setdefault("PYTHON_JULIACALL_CHECK_BOUNDS", "yes") DEVICE = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") pytestmark = [pytest.mark.medium] + ([pytest.mark.gpu] if DEVICE != "cpu" else []) From 462908b56ebffb27005f8b0cf2143bee017bbe94 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 17:31:56 +0000 Subject: [PATCH 014/107] Julia: drop the vector exp/log experiment [skip ci] Branch-free vlog/vexp vectorise in isolation (1 ulp), but the plasma's table gather keeps its loops scalar, and the cached scalar exponential is faster there: argon's plasma 1.03 s -> 1.44 s with them. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/vmath.jl | 51 ---------------------------------------------- 1 file changed, 51 deletions(-) delete mode 100644 julia/src/vmath.jl diff --git a/julia/src/vmath.jl b/julia/src/vmath.jl deleted file mode 100644 index 008abc580..000000000 --- a/julia/src/vmath.jl +++ /dev/null @@ -1,51 +0,0 @@ -# SPDX-FileCopyrightText: 2026 John C. Travers and contributors -# SPDX-License-Identifier: GPL-3.0-or-later - -# Branch-free exp and log in binary64, which a SIMD loop vectorises: Base's look up -# tables and branch, so a loop of them runs one lane at a time. Native calls SLEEF's -# 1-ulp vector functions for the same reason (native/include/solprop_native/vmath.hpp). -# Both here are within about one ulp (julia/test/runtests.jl checks it); binary32 and -# complex arguments keep Base's. - -const LN2_HI = 6.93147180369123816490e-01 -const LN2_LO = 1.90821492927058770002e-10 - -"""`exp(x)` by Cody-Waite reduction to |r| <= ln2/2 and its Taylor series to r^13.""" -@inline function vexp(x::Float64) - n = round(x * 1.4426950408889634) - r = muladd(-n, LN2_LO, muladd(-n, LN2_HI, x)) - # r^14/14! < 5e-18 at |r| = ln2/2: below half an ulp of the sum. - p = evalpoly(r, (1.0, 1.0, 1 / 2, 1 / 6, 1 / 24, 1 / 120, 1 / 720, 1 / 5040, 1 / 40320, - 1 / 362880, 1 / 3628800, 1 / 39916800, 1 / 479001600, 1 / 6227020800)) - # 2^n in two exact factors, so that a subnormal result keeps its bits. - k = unsafe_trunc(Int64, clamp(n, -2000.0, 2000.0)) - half = k >> 1 - scale1 = reinterpret(Float64, (clamp(half, -1022, 1023) + 1023) << 52) - scale2 = reinterpret(Float64, (clamp(k - half, -1022, 1023) + 1023) << 52) - value = p * scale1 * scale2 - value = ifelse(x > 709.782712893384, Inf, value) - value = ifelse(x < -745.1332191019412, 0.0, value) - ifelse(isnan(x), x, value) -end -@inline vexp(x) = exp(x) - -"""`log(x)` for positive normal `x` (fdlibm's e_log.c, without its branches).""" -@inline function vlog(x::Float64) - bits = reinterpret(UInt64, x) - e = Int64((bits >> 52) & 0x7ff) - 1023 - m = reinterpret(Float64, (bits & 0x000fffffffffffff) | 0x3ff0000000000000) - high = m > 1.4142135623730951 - m = ifelse(high, 0.5 * m, m) - k = Float64(e + high) - f = m - 1.0 - hfsq = 0.5 * f * f - s = f / (2.0 + f) - z = s * s - w = z * z - t1 = w * evalpoly(w, (3.999999999940941908e-01, 2.222219843214978396e-01, 1.531383769920937332e-01)) - t2 = z * evalpoly(w, (6.666666666666735130e-01, 2.857142874366239149e-01, - 1.818357216161805012e-01, 1.479819860511658591e-01)) - R = t2 + t1 - k * LN2_HI - ((hfsq - (s * (hfsq + R) + k * LN2_LO)) - f) -end -@inline vlog(x) = log(x) From aa6b94782a697e0363de9066fa14a22c360e17cf Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 17:39:11 +0000 Subject: [PATCH 015/107] Julia: observation populations a sample a thread on GPUs [skip ci] The populations' column scans were 70 % of an A40 rdw window (20 ms per call, one thread a column); they now take the current's per-sample form, their column diagnostics array reductions. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/responses.jl | 51 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 49 insertions(+), 2 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 615ed64f3..78ddfda47 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -324,8 +324,55 @@ function add_plasma!(destination, p, plan, c; coarse=false, direct=false) end end -"""Fresh accepted-field populations, for an observation: rates and exposure only.""" -function population_parts!(p, nodes, c, first, count) +"""Fresh accepted-field populations, for an observation: rates and exposure only. + +Return the six diagnostics' maxima over the chunk (`plasma_integration_statistics`), +and set its nodes' final fractions and peak rates. A GPU forms them a sample a thread, +with the column diagnostics as array reductions, as it forms the current. +""" +population_parts!(p, nodes, c, first, count) = + oncpu(c) && !SAMPLE_PLASMA[] ? population_columns!(p, nodes, c, first, count) : + population_samples!(p, nodes, c, first, count) + +function population_samples!(p, nodes, c, first, count) + T = typeof(p.dt) + (; rate, fraction, integrand, current, gated, edge, taps, dt, fractions, peaks) = p + floor, args = p.floor, rate_arguments(p) + initial, none = T(p.parameters[9]), zero(T) + nt, reach = size(nodes, 1), 2 * (length(taps) - 1) + each!(c, nt, count) do t, n + @inbounds rate[t, n] = rate_value(nodes[t, n], args...) + end + integrate_samples!(fraction, rate, current, taps, dt, c, count) + columns = 1:count + # The exposure's steps, then its fractions, the depletion they pay and the integrand. + each!(c, nt, count) do t, n + @inbounds integrand[t, n] = t == 1 ? none : fraction[t, n] - fraction[t-1, n] + end + each!(c, nt, count) do t, n + @inbounds begin + exposure = fraction[t, n] + value = 1 - (1 - initial) * exp(-(floor ? max(exposure, none) : exposure)) + fraction[t, n] = value + gated[t, n] = rate[t, n] * (1 - value) + current[t, n] = abs(value * nodes[t, n]) + end + end + each!(c, nt, count) do t, n + @inbounds edge[t, n] = t == 1 ? none : dt * (gated[t, n] + gated[t-1, n]) / 2 + end + steps = @view integrand[:, columns] + final, start = @view(fraction[nt, columns]), @view(fraction[1, columns]) + copyto!(@view(fractions[first:first+count-1]), final) + copyto!(@view(peaks[first:first+count-1]), vec(maximum(@view(rate[:, columns]); dims=1))) + freed = Array(final) .- Array(start) + paid = vec(Array(sum(@view(edge[:, columns]); dims=1))) + Float64[max(0, maximum(-, steps)), max(0, maximum(steps)), maximum(abs.(paid .- freed)), + maximum(freed), maximum(@view(current[1:min(reach, nt), columns])), + maximum(@view(current[:, columns]))] +end + +function population_columns!(p, nodes, c, first, count) T = typeof(p.dt) (; rate, fraction, taps, dt, fractions, peaks, parts) = p floor, args = p.floor, rate_arguments(p) From e026295d57cdd2ce6c15bf1209fb95556b30c7a2 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 17:43:49 +0000 Subject: [PATCH 016/107] parallel_rows: check the pass's size before reading the thread budget [skip ci] thread_budget() reads a sysfs file per CPU; parallel_rows asked for it before seeing that a pass was too small to thread, so every host statistic at every saved plane paid it: 60 ms of a 0.36 s rdw window. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- src/solprop/_process.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/solprop/_process.py b/src/solprop/_process.py index 1689be4ae..c6277b172 100644 --- a/src/solprop/_process.py +++ b/src/solprop/_process.py @@ -641,8 +641,12 @@ def parallel_rows[T](n_rows: int, nbytes: int, work: Callable[[slice], T]) -> li list Each call's result, in row order. """ + # The size first: the budget reads the CPU topology from sysfs (a file per CPU), + # which a small pass at every saved plane would otherwise pay each time. + if nbytes < PARALLEL_BYTES: + return [work(slice(0, n_rows))] workers = min(thread_budget().threads, n_rows) - if nbytes < PARALLEL_BYTES or workers <= 1: + if workers <= 1: return [work(slice(0, n_rows))] edges = [n_rows * index // workers for index in range(workers + 1)] with ThreadPoolExecutor(workers) as pool: From 90840a436943a77fd4e07658e642549b7c43e1e6 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 18:06:34 +0000 Subject: [PATCH 017/107] Julia: pool copies across the bridge; edge synthesis on the pool; no statistics, no copy [skip ci] The host fills a buffer the engine copies into (and loads from) with the pool's threads: a 226 MB Cartesian state's single-threaded first-touch copy took 75-220 ms. The radial edge's synthesis is the pool's GEMM (2.9 -> 0.44 ms a read), the crossing's buckets convert in place, and an empty statistics spec copies nothing. Cartesian 192 window 1.72 -> 1.10 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 1 + julia/src/observe.jl | 38 +++++++++++++++++++++----- src/solprop/backends/julia/_backend.py | 26 ++++++++++++------ 3 files changed, 49 insertions(+), 16 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 0c7453619..856e481a6 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -195,6 +195,7 @@ const rk4_b = rk4! const configure_stages_b = configure_stages! const load_b = load! const bind_monitor_b = bind_monitor! +const copy_state_b = copy_state! const bind_edge_b = bind_edge! const trial_b = trial! const commit_b = commit! diff --git a/julia/src/observe.jl b/julia/src/observe.jl index 9d1c477d3..d8a400972 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -10,14 +10,32 @@ host_candidate(engine) = host_view(engine.work.candidate) host_view(a::Matrix{ComplexF64}) = a host_view(a) = Matrix{ComplexF64}(Array(a)) +"""A Python buffer's memory as a Julia array; the caller keeps the buffer alive.""" +host_wrap(buffer, T) = (array = PyArray{T}(buffer); unsafe_wrap(Array, pointer(array), size(array))) + +"""Copy a state between the engine and a host (n_omega, n_modes) column-major buffer. + +On a CPU the pool's tasks copy, each touching its own pages: a single-threaded copy +of a 226 MB Cartesian state into fresh host memory took 75-220 ms. +""" +function copy_between!(target, source, c) + if oncpu(c) && eltype(target) == eltype(source) + each!(c, size(target)...) do f, m + @inbounds target[f, m] = source[f, m] + end + else + copyto!(target, convert(Array{eltype(target)}, Array(source))) + end + target +end +copy_state!(engine, buffer) = + (@section :observe copy_between!(host_wrap(buffer, ComplexF64), engine.work.y, engine.config); nothing) + """Load a host state given as its (n_omega, n_modes) column-major view.""" function load!(engine, input) y = engine.work.y - if y isa Matrix{ComplexF64} - copyto!(y, PyArray(input)) - else - copyto!(y, Matrix{eltype(y)}(PyArray(input))) - end + source = host_wrap(input, ComplexF64) + oncpu(engine.config) ? copy_between!(y, source, engine.config) : copyto!(y, eltype(y).(source)) reset!(engine) end @@ -29,7 +47,13 @@ function bind_monitor!(engine, columns, buckets) weights = columns === nothing ? ones(T, nm) : T.(Vector{Float64}(columns)) copyto!(w.monitor.columns, weights) if buckets !== nothing - copyto!(w.monitor.buckets, Int32.(permutedims(Matrix{Int}(buckets))) .+ Int32(1)) + # The (n_omega, n_modes) view of the crossing's table, converted by the pool. + table = host_wrap(buckets, UInt8) + target = oncpu(c) ? w.monitor.buckets : similar(table, Int32) + each!(merge(c, (backend=KA.CPU(),)), size(table)...) do f, m + @inbounds target[f, m] = Int32(table[f, m]) + Int32(1) + end + oncpu(c) || copyto!(w.monitor.buckets, target) end nothing end @@ -162,7 +186,7 @@ function edge_energy(engine) return nodes end synthesised = edge.synthesised - mul!(synthesised, y, edge.matrix) + gemm!(synthesised, y, edge.matrix, true, false, c) colsum!(c, out, size(synthesised)...) do f, m @inbounds abs2(synthesised[f, m]) end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 98d2ad94b..b935d9677 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -480,8 +480,7 @@ def _warm_bridge(self) -> None: jl, engine = self._jl, self._engine # A crossing's bucket table is read-only, which is part of its bridge type. buckets = np.zeros((n_modes, n_omega), dtype=np.uint8) - buckets.setflags(write=False) - for columns, table in ((None, None), (np.ones(n_modes), buckets)): + for columns, table in ((None, None), (np.ones(n_modes), buckets.T)): call_julia(jl.bind_monitor_b, engine, columns, table) for name in ("state_power", "occupancy", "split_power", "column_energy"): np.asarray(call_julia(getattr(jl, name), engine)) @@ -490,7 +489,7 @@ def _warm_bridge(self) -> None: call_julia(jl.bind_edge_b, engine, inverse, np.zeros(1, dtype=np.int64)) call_julia(jl.node_energy, engine) call_julia(jl.device_name, engine) - np.asarray(call_julia(jl.host_state, engine)) + self._observed_field(engine) if self._problem.flags.has_plasma: call_julia( jl.population_snapshot, @@ -544,8 +543,9 @@ def _apply_mask( object Opaque Julia engine handle. """ - # A column-major (n_omega, n_modes) view: the engine copies it once. - call_julia(self._jl.load_b, self._engine, state[0, :, 0, :].T) + # A column-major (n_omega, n_modes) view of a contiguous copy: the engine reads it. + values = np.ascontiguousarray(state[0, :, 0, :], dtype=np.complex128) + call_julia(self._jl.load_b, self._engine, values.T) self._fsal = False self._alarm = math.nan return self._engine @@ -718,9 +718,13 @@ def _observed_field( numpy.ndarray Independent complex128 host array in the seam layout. """ - # The engine's own column-major array, viewed: one copy makes it the host's. - values = np.asarray(call_julia(self._jl.host_state, state)) - return np.array(values.T, dtype=np.complex128)[None, :, None, :] + del state + # The engine fills a host array, through its column-major (n_omega, n_modes) + # view, with the pool's threads. + _, n_modes, _, n_omega = self._problem.shape + values = np.empty((n_modes, n_omega), dtype=np.complex128) + call_julia(self._jl.copy_state_b, self._engine, values.T) + return values[None, :, None, :] def _bind_monitor(self, monitor: BoundaryMonitor | None) -> None: """Hold the monitor's column weights and rate buckets in the engine. @@ -738,7 +742,9 @@ def _bind_monitor(self, monitor: BoundaryMonitor | None) -> None: self._jl.bind_monitor_b, self._engine, None if monitor.columns is None else np.asarray(monitor.columns), - None if crossing is None else np.asarray(crossing.buckets), + None + if crossing is None + else np.ascontiguousarray(crossing.buckets, dtype=np.uint8).T, ) def _edge_reading( @@ -858,6 +864,8 @@ def stats(self, spec: StatsSpec) -> dict[str, np.ndarray]: """ spatial = self._problem.transform.geometry is not None _refuse_stats(spec, spatial=spatial) + if not spec.names: + return {} if self._varying: self._weight = power_weight_at(self._problem, self._z) self._prepare_stages(self._z, 0.0) From cba02096893501b5075481e64a7b073afb446ba5 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 18:41:40 +0000 Subject: [PATCH 018/107] Julia: binary32 (SEP 33) from the same source [skip ci] precision="single" runs the engine with T=Float32: the state held as a / s, s the launch's power-of-two scale; the cubic responses take s^2, the plasma rate the physical field s E and the loss potential 1/s^2; the controller's atol is divided by s. The operator and free space's separable tables stay binary64, so propagators, the longitudinal root and the Adams flow are formed in binary64 and rounded once. Tests compare with numpy_ref's binary32 path to 1e-4. The harness's julia32 names the julia backend in single precision. On x86 the binary32 window is slower than binary64: the scaled field's tails make subnormals, and flush-to-zero is not allowed (AGENTS.md); with it, the Kerr pass was 20x faster. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- benchmarks/ab.py | 5 ++-- benchmarks/registry.py | 6 +++-- benchmarks/track.py | 5 ++-- julia/src/SolpropJulia.jl | 2 ++ julia/src/adams.jl | 5 +++- julia/src/dopri.jl | 3 +-- julia/src/free.jl | 24 +++++++++++-------- julia/src/modal.jl | 6 +++-- julia/src/observe.jl | 29 +++++++++++++++-------- julia/src/responses.jl | 13 +++++++---- julia/src/stages.jl | 7 +++--- src/solprop/backends/julia/_backend.py | 23 ++++++++++++++---- src/solprop/translate/precision.py | 2 +- tests/backends/test_julia.py | 32 ++++++++++++++++++-------- 14 files changed, 108 insertions(+), 54 deletions(-) diff --git a/benchmarks/ab.py b/benchmarks/ab.py index f56eb2c02..906e3dff9 100644 --- a/benchmarks/ab.py +++ b/benchmarks/ab.py @@ -83,8 +83,9 @@ def arm_configuration(configuration: Record, backend: str) -> Record: """Return one arm's configuration: its backend and that backend's precision.""" return { **configuration, - "backend": backend, - "precision": "single" if backend == "mlx" else "double", + # "julia32" is the julia backend in single precision (the Julia experiment). + "backend": "julia" if backend == "julia32" else backend, + "precision": "single" if backend in ("mlx", "julia32") else "double", } diff --git a/benchmarks/registry.py b/benchmarks/registry.py index 72a581887..9752e6faa 100644 --- a/benchmarks/registry.py +++ b/benchmarks/registry.py @@ -139,14 +139,16 @@ def configuration( # noqa: PLR0913 - the shared command-line selection raise SuiteError(f"{self.name} admits only {', '.join(self.steppers)}") if not 0 < fraction <= 1 or not 0 <= warmup < 1: raise SuiteError("length fraction must be in (0, 1], warm-up in [0, 1)") + # "julia32" is the julia backend in single precision (the Julia experiment). + single = backend in ("mlx", "julia32") return { "case": self.name, "revision": self.revision, "case_hash": self.digest, "stepper": stepper, "threads": width, - "backend": backend, - "precision": "single" if backend == "mlx" else "double", + "backend": "julia" if backend == "julia32" else backend, + "precision": "single" if single else "double", "noise": noise, "fft_size": fft_size, "device": device, diff --git a/benchmarks/track.py b/benchmarks/track.py index eaa79601c..63ef66717 100644 --- a/benchmarks/track.py +++ b/benchmarks/track.py @@ -36,8 +36,9 @@ thread_environment, ) -BACKENDS = ("numpy_ref", "native", "mlx", "julia") -"""The backends a benchmark can name; ``mlx`` only on an Apple GPU.""" +BACKENDS = ("numpy_ref", "native", "mlx", "julia", "julia32") +"""The backends a benchmark can name; ``mlx`` only on an Apple GPU, ``julia32`` the +julia backend in single precision.""" REPEAT_TOLERANCE = 1e-9 """The relative L2 difference two repeats' final fields may have: rounding only.""" diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 856e481a6..2a59c88d6 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -72,6 +72,8 @@ function create(input) analytic_factor=T(host.real("analytic_factor")), factor=host.real("factor"), rtol=host.real("rtol"), atol=host.real("atol"), cache_propagators=host.has("cache_propagators") ? host.flag("cache_propagators") : true, + # A binary32 state is held as a / s, s an exact power of two (SEP 33, rule 2). + scale=host.has("state_scale") ? host.real("state_scale") : 1.0, ) engine = c.free ? create_free(c, host) : create_modal(c, host) oncpu(c) || (SYNCHRONIZE[] = () -> KA.synchronize(backend)) diff --git a/julia/src/adams.jl b/julia/src/adams.jl index d23553c3e..6e34af5b1 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -80,7 +80,10 @@ function adams_workspace(c, host, nw, nm) slots=zeros(Int, slots)) (store=dzeros(c, C, nw, nm, slots), states=held(nw, nm, slots), rates=held(nw, nm, slots), moments=dzeros(c, C, nw, nm, width), carried=held(nw, nm, max(width - 1, 0)), - endpoint=held(nw, nm), host=tables, device=map(a -> upload(c.backend, copy(a)), tables), + # The device's tables at the state's precision: a binary64 coefficient beside a + # binary32 state would widen a trial's every product (and its norms' types). + endpoint=held(nw, nm), host=tables, + device=map(a -> upload(c.backend, eltype(a) <: Integer ? copy(a) : c.T.(a)), tables), sizes=zeros(Int, 3), compensated=compensated) end diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 60c2153be..a815989f0 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -14,8 +14,7 @@ function propagators!(engine, dz) c.cache_propagators && engine.propagator_dz == dz && return nothing (; linear) = c (; forward, inverse) = w - T = real_type(engine) - steps = ntuple(s -> T(dz * c.nodes_c[s]), Val(7)) + steps = ntuple(s -> dz * c.nodes_c[s], Val(7)) each!(c, size(linear)...) do f, m @inbounds for s in 1:7 exponent = steps[s] * linear[f, m] diff --git a/julia/src/free.jl b/julia/src/free.jl index b8bb6221b..5a042262b 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -18,14 +18,17 @@ function create_free(c, host) # Both inverse transforms are unnormalised; their 1/(nt n_x n_y) goes into the # factor that forms the physical field from them. scale = inv(T(nt) * T(nm)) + # The separable operator stays binary64 at either precision: the longitudinal root's + # compensated subtraction decides its branch near grazing (free_element). + R64, C64 = Float64, ComplexF64 op = ( - k_squared=upload(c, host.array("k_squared", C)), k_squared_low=upload(c, host.array("k_squared_low", C)), - kperp_sq=upload(c, host.array("kperp_sq", T)), kperp_sq_low=upload(c, host.array("kperp_sq_low", T)), - frame=upload(c, host.array("frame", T)), spectral_rate=upload(c, host.array("spectral_rate", T)), - prefactor_numerator=upload(c, host.array("prefactor_numerator", C)), - prefactor_clamped=upload(c, host.array("prefactor_clamped", C)), - active=upload(c, host.array("active", Bool)), kperp_rate=upload(c, host.array("kperp_rate", T)), - evanescent_rate=T(host.real("evanescent_rate")), + k_squared=upload(c, host.array("k_squared", C64)), k_squared_low=upload(c, host.array("k_squared_low", C64)), + kperp_sq=upload(c, host.array("kperp_sq", R64)), kperp_sq_low=upload(c, host.array("kperp_sq_low", R64)), + frame=upload(c, host.array("frame", R64)), spectral_rate=upload(c, host.array("spectral_rate", R64)), + prefactor_numerator=upload(c, host.array("prefactor_numerator", C64)), + prefactor_clamped=upload(c, host.array("prefactor_clamped", C64)), + active=upload(c, host.array("active", Bool)), kperp_rate=upload(c, host.array("kperp_rate", R64)), + evanescent_rate=host.real("evanescent_rate"), ) c = merge(c, ( spatial_shape=shape, op=op, field_scale=T(host.real("pad_scale")) * scale, @@ -105,7 +108,7 @@ function free_propagators!(engine, h) fill!(forward, 1) fill!(inverse, 1) else - op, both, distance = c.op, !c.low_storage, real_type(engine)(h) + op, both, distance = c.op, !c.low_storage, Float64(h) each!(c, size(forward, 1), size(forward, 2)) do f, m @inbounds begin exponent = distance * first(free_element(op, f, m)) @@ -189,7 +192,8 @@ function source_free!(engine, lab) extra = live ? loss : physical each!(c, size(source)...) do f, m @inbounds begin - value = last(free_element(op, f, m)) * omega_window[f] * physical[f, m] + prefactor = oftype(physical[f, m], last(free_element(op, f, m))) + value = prefactor * omega_window[f] * physical[f, m] if live && mask[f] value += extra[f, m] end @@ -259,7 +263,7 @@ function population_free_snapshot(engine, input) c, w = engine.config, engine.work p = w.plasma (; physical, fine, modal, projected) = w - copyto!(physical, device_matrix(engine, input)) + copyto!(physical, device_matrix(engine, input) .* real_type(engine)(inv(c.scale))) transverse!(physical, w.spatial_inverse, c) chunk, nm = size(modal, 2), size(physical, 2) scale = c.field_scale diff --git a/julia/src/modal.jl b/julia/src/modal.jl index e70f4d8e0..95aa3f4bb 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -42,7 +42,9 @@ function create_modal(c, host) # Every inverse transform is unnormalised: its 1/nt is folded into the tables that # read the time-domain field, the synthesis and the in-stage absorber. c = merge(c, ( - linear=upload(c, host.array("linear", C)), prefactor=upload(c, host.array("prefactor", C)), + # The operator stays binary64 at either precision: propagators and the Adams + # flow are formed from it in binary64 and rounded once (SEP 33, 4.1 item 3). + linear=upload(c, host.array("linear", ComplexF64)), prefactor=upload(c, host.array("prefactor", C)), synthesis=upload(c, T.(synthesis ./ nt)), projection=upload(c, host.array("projection", T)), projection_coarse=upload(c, host.array("projection_coarse", T)), embedded=host.flag("embedded"), spatial_absorber=upload(c, T.(spatial ./ nt)), @@ -179,7 +181,7 @@ function population_snapshot(engine, input) engine.config.free && return population_free_snapshot(engine, input) c, w = engine.config, engine.work p = w.plasma - scatter!(w.fine, device_matrix(engine, input), c) + scatter!(w.fine, device_matrix(engine, input) .* real_type(engine)(inv(c.scale)), c) mul!(w.modal, w.inverse_plan, w.fine) chunk, nn = size(w.nodes, 2), size(c.synthesis, 2) maxima = zeros(6) diff --git a/julia/src/observe.jl b/julia/src/observe.jl index d8a400972..39e9d7654 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -28,14 +28,25 @@ function copy_between!(target, source, c) end target end -copy_state!(engine, buffer) = - (@section :observe copy_between!(host_wrap(buffer, ComplexF64), engine.work.y, engine.config); nothing) +function copy_state!(engine, buffer) + @section :observe begin + target = copy_between!(host_wrap(buffer, ComplexF64), engine.work.y, engine.config) + scale = engine.config.scale + scale == 1 || (target .*= scale) + end + nothing +end """Load a host state given as its (n_omega, n_modes) column-major view.""" function load!(engine, input) y = engine.work.y source = host_wrap(input, ComplexF64) - oncpu(engine.config) ? copy_between!(y, source, engine.config) : copyto!(y, eltype(y).(source)) + inverse = inv(engine.config.scale) + if oncpu(engine.config) && eltype(y) == ComplexF64 && inverse == 1 + copy_between!(y, source, engine.config) + else + copyto!(y, upload(engine.config, eltype(y).(source .* inverse))) + end reset!(engine) end @@ -92,9 +103,9 @@ function monitor_power(engine) mul!(w.coarse, w.coarse_inverse, w.lab) add_power!(power, w.coarse, columns, 1, size(w.y, 2), c) end - Vector{Float64}(Array(power)) + Vector{Float64}(Array(power)) .* engine.config.scale^2 end -split_power(engine) = Vector{Float64}(Array(engine.work.monitor.split)) +split_power(engine) = Vector{Float64}(Array(engine.work.monitor.split)) .* engine.config.scale^2 function columns_into!(target, source, first, count, c) each!(c, size(target)...) do f, m @@ -124,7 +135,7 @@ function occupancy(engine) @inbounds Atomix.@atomic histogram[buckets[f, m], 1] += abs2(y[f, m]) * columns[m] end end - vec(sum(Array{Float64}(Array(histogram)); dims=2)) + vec(sum(Array{Float64}(Array(histogram)); dims=2)) .* engine.config.scale^2 end # --- the transverse edge (SEP 44): per-node and per-column energies ----------------- @@ -148,7 +159,7 @@ function column_energy(engine) colsum!(engine.config, out, size(y)...) do f, m @inbounds abs2(y[f, m]) end - Vector{Float64}(Array(out)) + Vector{Float64}(Array(out)) .* engine.config.scale^2 end """Hold a radial read's synthesis rows (0-based `rows` of `inverse`) for `node_energy`.""" @@ -183,7 +194,7 @@ function edge_energy(engine) end all = Array(out) nodes[edge.selected] .= all[edge.selected] - return nodes + return nodes .* c.scale^2 end synthesised = edge.synthesised gemm!(synthesised, y, edge.matrix, true, false, c) @@ -191,5 +202,5 @@ function edge_energy(engine) @inbounds abs2(synthesised[f, m]) end nodes[edge.selected] .= Array(out) - nodes + nodes .* c.scale^2 end diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 78ddfda47..526cdf039 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -80,7 +80,7 @@ function plasma_workspace(c, host, nt, chunk, nm, nn) # ionisation potential; density and preionisation are a stage's (stages.jl). parameters=host.array("plasma_parameters", Float64), taps=upload(c, host.array("plasma_taps", T)), floor=host.flag("plasma_floor"), - dt=T(host.real("dt")), + dt=T(host.real("dt")), field_scale=T(c.scale), inverse_omega=upload(c, T.(inv.(host.array("omega", Float64)))), derivative=upload(c, host.array("window_derivative", T)), rate=dzeros(c, T, nt, chunk), fraction=dzeros(c, T, nt, chunk), @@ -105,7 +105,10 @@ end @inbounds value = ((table[1, j] * s + table[2, j]) * s + table[3, j]) * s + table[4, j] min(exp(value), cap) end -@inline rate_arguments(p) = (p.coefficients, ntuple(k -> typeof(p.dt)(p.parameters[k]), 5)...) +@inline rate_arguments(p) = + (p.field_scale, p.coefficients, ntuple(k -> typeof(p.dt)(p.parameters[k]), 5)...) +"""The rate at a scaled field's physical value `s E`: exact, s a power of two.""" +@inline scaled_rate(value, scale, args...) = rate_value(scale * value, args...) # A symmetric FIR, reflected at the ends as RunningIntegral is, then a running # trapezoid. The scan's order is strict: no reassociation. @@ -181,7 +184,7 @@ end @inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args) peak = zero(dt) @inbounds for t in axes(nodes, 1) - value = rate_value(nodes[t, node], args...) + value = scaled_rate(nodes[t, node], args...) rate[t, node] = value peak = max(peak, value) end @@ -226,7 +229,7 @@ function plasma_samples!(p, nodes, c, count) density, initial = T(p.parameters[8]), T(p.parameters[9]) nt, none = size(nodes, 1), zero(T) each!(c, nt, count) do t, n - @inbounds rate[t, n] = rate_value(nodes[t, n], args...) + @inbounds rate[t, n] = scaled_rate(nodes[t, n], args...) end integrate_samples!(fraction, rate, current, taps, dt, c, count) each!(c, nt, count) do t, n @@ -341,7 +344,7 @@ function population_samples!(p, nodes, c, first, count) initial, none = T(p.parameters[9]), zero(T) nt, reach = size(nodes, 1), 2 * (length(taps) - 1) each!(c, nt, count) do t, n - @inbounds rate[t, n] = rate_value(nodes[t, n], args...) + @inbounds rate[t, n] = scaled_rate(nodes[t, n], args...) end integrate_samples!(fraction, rate, current, taps, dt, c, count) columns = 1:count diff --git a/julia/src/stages.jl b/julia/src/stages.jl index ea0c2f566..a61418b39 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -8,11 +8,12 @@ function path_workspace(c, host) host.has("phi_terms") || return nothing C = Complex{c.T} - phi, pre = host.array("phi_terms", C), host.array("prefactor_terms", C) + # Phi's terms stay binary64, as the operator does (modal.jl). + phi, pre = host.array("phi_terms", ComplexF64), host.array("prefactor_terms", C) stages = 7 (phi=upload(c, phi), prefactor=upload(c, pre), delta=zeros(size(phi, 3), stages), weights=zeros(size(pre, 3), stages), - delta_device=dzeros(c, c.T, size(phi, 3), stages), + delta_device=dzeros(c, Float64, size(phi, 3), stages), weights_device=dzeros(c, c.T, size(pre, 3), stages), material=zeros(3, stages)) end @@ -22,7 +23,7 @@ function configure_stages!(engine, delta, weights, material) copyto!(p.delta, Matrix{Float64}(delta)) copyto!(p.weights, Matrix{Float64}(weights)) copyto!(p.material, Matrix{Float64}(material)) - copyto!(p.delta_device, real_type(engine).(p.delta)) + copyto!(p.delta_device, p.delta) copyto!(p.weights_device, real_type(engine).(p.weights)) material_stage!(engine, 1) nothing diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index b935d9677..03a2465bd 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -45,6 +45,7 @@ from solprop.stepper.tableau import DOPRI5 from solprop.translate.chebyshev import PiecewiseChebyshev from solprop.translate.linop import power_weight_at +from solprop.translate.precision import launch_peak, state_scale from solprop.translate.problem import KernelProblem from solprop.translate.stage import terms @@ -117,7 +118,6 @@ def _refuse(problem: KernelProblem) -> None: problem.stepper, ) reasons = { - "single precision": problem.precision.single, "envelope plasma": problem.grid_kind == "envelope" and problem.flags.has_plasma, "resolved modal or radial envelopes": problem.grid_kind == "envelope" and transform.kind not in {"free", "mode_averaged"}, @@ -248,7 +248,15 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: # One pool runs every pass, transforms and products included (julia/src/launch.jl): # a transform is split into at most this many blocks of whole columns. fft_threads = thread_limit("SOLPROP_JULIA_FFT_THREADS", threads) + # A binary32 run holds its state as a / s (SEP 33, rule 2): the cubic responses + # take s**2, the plasma reads the physical field s E (the engine's) and its loss + # potential 1 / s**2, and the controller's absolute tolerance is divided by s. + single = problem.precision.single + scale = state_scale(launch_peak(problem.initial.field0, problem.grid_kind)) if single else 1.0 + factor *= scale**2 config: dict[str, object] = { + "precision": "single" if single else "double", + "state_scale": scale, "adams_order": problem.stepper.integrator.order if isinstance(problem.stepper.integrator, Multistep) else 0, @@ -302,7 +310,7 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: else kerr.self_factor + kerr.conjugate_factor, "split": responses.absorber_scheme == "split_step", "rtol": control.rtol, - "atol": control.atol, + "atol": control.atol / scale, "cache_propagators": transform.kind != "free" and problem.stepper.propagator_mode != "recompute", "threads": threads, @@ -341,7 +349,7 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: table.log_field_min, table.d_log_field, channel.charge_mass_ratio, - channel.ionisation_potential, + channel.ionisation_potential / scale**2, float(channel.density(0.0)), float(channel.preionisation(0.0)), ] @@ -359,7 +367,7 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: raman_undamped=raman.undamped.T.copy(), raman_rates=np.array([float(rate(0.0)) for rate in raman.decay_rates]), raman_fraction=raman.fraction, - raman_factor=EPS0 * float((raman.density or responses.density)(0.0)), + raman_factor=EPS0 * float((raman.density or responses.density)(0.0)) * scale**2, raman_thg=raman.thg, dt=grids.dt_fine, ) @@ -444,6 +452,11 @@ def __init__( self._jl.create, _configuration(problem, self._threads) ) self._varying = _varying(problem) + self._scale2 = ( + state_scale(launch_peak(problem.initial.field0, problem.grid_kind)) ** 2 + if problem.precision.single + else 1.0 + ) if self._varying: self._prepare_stages(0.0, 0.0) self._plan_flag = os.environ.get("SOLPROP_FFTW_PLAN") or "measure" @@ -639,7 +652,7 @@ def _prepare_stages(self, z: float, dz: float) -> None: material = np.array( [ [ - 0.0 if kerr is None else kerr.coefficient * b.kerr_density, + 0.0 if kerr is None else kerr.coefficient * b.kerr_density * self._scale2, b.plasma_densities[0] if b.plasma_densities else 0.0, b.preionisation, ] diff --git a/src/solprop/translate/precision.py b/src/solprop/translate/precision.py index 250a13ae3..79e2cf3ed 100644 --- a/src/solprop/translate/precision.py +++ b/src/solprop/translate/precision.py @@ -82,7 +82,7 @@ is admitted. """ -SINGLE_PRECISION_BACKENDS: tuple[str, ...] = ("numpy_ref", "mlx") +SINGLE_PRECISION_BACKENDS: tuple[str, ...] = ("numpy_ref", "mlx", "julia") """The backends that admit ``precision="single"``. ``numpy_ref`` is the single-precision oracle (SEP 33 phase 1) and ``mlx`` the Apple-GPU diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index ec9d2e473..4b981ac55 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -94,16 +94,6 @@ def test_julia_matches_the_reference(runtime, case, stepper, fraction): assert float(np.linalg.norm(field - reference)) <= 1e-10 * scale -def test_julia_refuses_single_precision(runtime): - """Single precision is not admitted until its error budgets are qualified.""" - del runtime - configuration = CASES["rdw"].configuration("rk", 1, "julia", fraction=0.001) - simulation = build(configuration | {"precision": "single", "backend": "numpy_ref"}) - problem = simulation.translate() - with pytest.raises(BackendError, match="single precision"): - select("julia", problem, grid=simulation.grid, modes=simulation.modes) - - def test_julia_reports_its_engine(runtime): """Metadata names the runtime and the sources; the ledger counts owned arrays.""" del runtime @@ -118,3 +108,25 @@ def test_julia_reports_its_engine(runtime): ledger = engine.memory_ledger() assert ledger["work.y"] == 16 * problem.shape[1] * problem.shape[3] engine.close() + + +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS[:3] + WINDOWS[4:6]) +def test_julia_single_precision_tracks_the_reference(runtime, case, stepper, fraction): + """Binary32 (SEP 33) agrees with the binary32 reference on the same contract. + + A single-precision run's grid is its own, so the reference is numpy_ref's binary32 + path, not the binary64 run. The steps may differ: binary32's error estimate is + noisier near rtol's floor. + """ + del runtime + configuration = CASES[case].configuration( + stepper, 2, "julia", fraction=fraction, noise="none" + ) | {"precision": "single"} + field, _ = _run("julia", configuration) + reference, _ = _run("numpy_ref", configuration) + # SEP 33's whole-run field envelope is 1e-3; over these few steps two binary32 + # implementations differ by their rounding, ~1e-6 (PR #543's records), so 1e-4 + # holds two orders in hand and still catches a mis-scaled response (O(1)). + scale = float(np.linalg.norm(reference)) + assert float(np.linalg.norm(field - reference)) <= 1e-4 * scale From 367559c52583b5f6126104f8f6348b0accd700f7 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 19:09:40 +0000 Subject: [PATCH 019/107] Julia: block exponent for the Raman kernel; docs, status and manual page [skip ci] The Raman kernel's spectrum is held as spectrum * 2^-e with its factor taking 2^e (SEP 33's block exponent): in binary32 its small entries were subnormal, a 1.7 % field error on H2 Raman, now 1.5e-7 from numpy_ref's binary32 path; binary32's tests cover the Raman window too. julia/README, julia/STATUS, the manual page and a release-note fragment; the julia package is a recorded coverage omission, like mlx. The prototype's Julia-side tests and interop script are replaced by the pytest module. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- changelog.d/julia-backend-experiment.added.md | 1 + coverage-cpu.ini | 1 + docs/dev/testing.md | 8 + docs/guide/performance/backends.md | 1 + docs/guide/performance/index.md | 1 + docs/guide/performance/julia.md | 56 +++ julia/README.md | 312 +++-------------- julia/STATUS.md | 328 ++++++------------ julia/interop.py | 61 ---- julia/src/responses.jl | 7 +- julia/test/runtests.jl | 101 ------ tests/backends/test_julia.py | 2 +- 12 files changed, 238 insertions(+), 641 deletions(-) create mode 100644 changelog.d/julia-backend-experiment.added.md create mode 100644 docs/guide/performance/julia.md delete mode 100644 julia/interop.py delete mode 100644 julia/test/runtests.jl diff --git a/changelog.d/julia-backend-experiment.added.md b/changelog.d/julia-backend-experiment.added.md new file mode 100644 index 000000000..3f4ce88a9 --- /dev/null +++ b/changelog.d/julia-backend-experiment.added.md @@ -0,0 +1 @@ +An experimental `julia` backend (`backend="julia"`, the `julia` extra and a Julia 1.13 runtime prepared by `julia/bootstrap.py`) runs the scalar modal capillary, mode-averaged, radial, Cartesian and line routes on a CPU, or on an NVIDIA GPU with `SOLPROP_JULIA_DEVICE=cuda`, in binary64 or binary32, from one Julia source. It is an experiment, not a supported backend: `julia/STATUS.md` lists what it runs and refuses, and the [manual page](docs/guide/performance/julia.md) how to try it. diff --git a/coverage-cpu.ini b/coverage-cpu.ini index 388178712..cf78ad4f7 100644 --- a/coverage-cpu.ini +++ b/coverage-cpu.ini @@ -13,6 +13,7 @@ source = solprop branch = True omit = */solprop/backends/mlx_gpu/* + */solprop/backends/julia/* [report] fail_under = 100 diff --git a/docs/dev/testing.md b/docs/dev/testing.md index d2cc5644c..b4870665b 100644 --- a/docs/dev/testing.md +++ b/docs/dev/testing.md @@ -102,6 +102,14 @@ MLX's CPU device, and basedpyright on `mlx_gpu`. It is in [#85](https://github.com/LupoLab/solprop/issues/85) with the rest of the backend's path to full support ([backends.md](backends.md) §4a). +### The `julia` omission + +The experimental `julia` backend's package, `solprop/backends/julia`, is left out of the +coverage lane too (`omit` in `coverage-cpu.ini`). Its tests, +`tests/backends/test_julia.py`, skip unless `solprop[julia]` is installed and +`julia/bootstrap.py` has prepared a Julia runtime, which no CI lane does: the backend is +an experiment, not a release feature (`julia/STATUS.md`). + Hypothesis properties use the `solprop` profile loaded by `tests/conftest.py`. Their example count bounds the work; the per-example wall-clock deadline is disabled because imports, JIT compilation and contention on shared machines can exceed it diff --git a/docs/guide/performance/backends.md b/docs/guide/performance/backends.md index 4e33e28d2..60ec61b2b 100644 --- a/docs/guide/performance/backends.md +++ b/docs/guide/performance/backends.md @@ -13,6 +13,7 @@ native backend, which `"auto"` selects; `mlx` and `numpy_ref` are for the cases |---|---|---| | `native` | the [native backend](native.md), the solprop-native distribution built from the repository's `native/` directory and a required dependency of solprop: OpenMP, FFTW and a vendor BLAS on a CPU, or CUDA/HIP on a GPU | **the one to use**: what `"auto"` selects | | `mlx` | the Apple-silicon GPU through Apple's MLX, in **single precision only** ([single precision](single-precision.md)); the `mlx` extra, macOS on Apple silicon; **experimental** in this release | `precision="single"` capillary and fibre runs on a Mac, where it is the `"auto"` choice; it refuses `precision="double"` | +| `julia` | an **experiment** on this branch only: one Julia source for a CPU or an NVIDIA GPU, binary64 or binary32 ([the Julia experiment](julia.md)); the `julia` extra and a prepared Julia runtime | measuring what a compact single-source engine reaches; not for results | | `numpy_ref` | plain NumPy, the numerical **reference**: every other backend is tested against it. It is unthreaded, and roughly 6 to 40 times slower than threaded native | checking a result, and [the features native does not run](#features-that-run-on-the-reference-backend). Also problems a GPU build refuses or runs slowly, in a process that has only that build | ## Which backend a run uses diff --git a/docs/guide/performance/index.md b/docs/guide/performance/index.md index 68df1c223..c7ba05807 100644 --- a/docs/guide/performance/index.md +++ b/docs/guide/performance/index.md @@ -22,4 +22,5 @@ resources progress tuning single-precision +julia ``` diff --git a/docs/guide/performance/julia.md b/docs/guide/performance/julia.md new file mode 100644 index 000000000..ae8f60165 --- /dev/null +++ b/docs/guide/performance/julia.md @@ -0,0 +1,56 @@ +# The Julia experiment + +`backend="julia"` is an experiment on this branch, not a supported backend: it asks how +fast one compact Julia source can run solprop's routes on a CPU and on an NVIDIA GPU, +in binary64 or binary32. Use the [native backend](native.md) for results. The design, +the measurements and what is left are in the branch's `julia/STATUS.md`. + +## What it runs + +The translated problem is the same one every backend executes ([choosing a +backend](backends.md)); the julia backend steps it behind the same seam as native, and +refuses by name what it does not run. + +| | runs | refuses | +|---|---|---| +| routes | resolved and mode-averaged capillaries (constant radius, separable longitudinal profiles), radial, Cartesian and line free space | planar and general modal guides, tapers, coupled flows | +| responses | Kerr (with THG), one field-grid plasma channel, one constant Raman term (modal) | envelope plasma, several channels or Raman terms, varying Raman, dispersive Kerr, TDSE, noise | +| steppers | DOPRI5 with FSAL, the exponential Adams march (not Cartesian), RK4IP (Cartesian) | the interaction Adams formulation, the carrier frame, interpolated planes | +| execution | CPU threads; an NVIDIA GPU (`SOLPROP_JULIA_DEVICE=cuda`); `precision="double"` or `"single"` | vector polarisation, batches | + +## Trying it + +From a checkout of the branch: + +```sh +uv sync --extra julia +uv run --no-sync python julia/bootstrap.py # add --cuda for a GPU +SOLPROP_JULIA_THREADS=16 uv run --no-sync python my_run.py # with backend="julia" +``` + +The bootstrap downloads Julia 1.13.3 (checksummed) unless `SOLPROP_JULIA_EXE` names one, +and instantiates the committed manifest. A run's first propagation pays nothing for +Julia's compilation: the engine compiles and runs each of its paths once when it is +constructed, which takes seconds. `julia/README.md` lists the environment variables. + +## How it is built + +One source for every device and precision. Each state-sized operation is a scalar +function launched over the state by a small device layer: on a CPU, Polyester tasks +running contiguous SIMD loops; on a GPU, a KernelAbstractions kernel a sample a thread. +FFTs are AbstractFFTs plans (FFTW or cuFFT) and contractions `mul!` (BLAS or cuBLAS). +On a CPU one pool runs everything, the transforms as blocks of single-threaded plans and +the products as blocks of rows, because the libraries' own threads beside the pool's +made a run slower on four threads than on one. In binary32 the state is held as +`a / s` for SEP 33's power-of-two scale `s`, and the operator stays binary64, so +propagators and the longitudinal root are formed in binary64 and rounded once. + +## How fast it is + +Indicative only: short windows of the benchmark cases, measured with `python -m +benchmarks ab` against native on the same machine. The branch's ledger +([benchmarks](../../dev/benchmarks.md#julia-backend-experiment)) has the numbers, the +machines and the commits. On CPUs the julia backend is within one to three times +native's time; on an NVIDIA A40 within one to four times native's CUDA build. Most of +what is left is host work per step and per saved plane, which native does in compiled +code: the Adams march and the statistics. diff --git a/julia/README.md b/julia/README.md index 402e202e9..842ebeb93 100644 --- a/julia/README.md +++ b/julia/README.md @@ -1,273 +1,73 @@ -# Experimental Julia backend - -**Experiment — draft for collaboration, not for merge. No CI qualification.** -Start with the [status, measured results and next-work list](STATUS.md). This branch -now targets schema 35 after merging the native CPU optimisation branch and its -SEP 34 medium-flux dependency. Spatial statistics use the shared flux implementation; -the Julia numerical kernels are unchanged. - -This source-only CPU prototype implements solprop schema 35 behind -`backend="julia"`. It is an isolated experiment, authorised before a production SEP. -It preserves automatic backend selection and Python frontend signatures. The -[manual](../docs/guide/performance/julia.md) describes the supported cases and example. - -## Prepare a checkout - -Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and Git first. -Use this branch's source checkout, not a released solprop wheel. On Apple Silicon -or Linux x86_64: - -```sh -git clone --branch feature/julia-backend-prototype https://github.com/LupoLab/solprop.git solprop-julia -cd solprop-julia -uv sync --python 3.14 --extra julia -uv run --no-sync python julia/bootstrap.py -SOLPROP_JULIA_THREADS=1 uv run --no-sync python julia/example.py -SOLPROP_JULIA_THREADS=4 uv run --no-sync python julia/example.py -``` - -For an existing checkout, start at `uv sync`. Native is optional and is not needed -for these example runs. Bootstrap needs network access and several GB of disk -space for the runtime, packages and compilation caches; the first propagation can -spend substantially longer compiling than later windows spend propagating. The -example is a short four-mode Kerr capillary, ending at 0.1 mm, and prints a completion -message. It keeps output in memory. More geometries are shown in the manual. - -The bootstrap downloads the official Julia 1.13.2 archive, verifies its SHA256 against -the digest published in Julia's -[release manifest](https://julialang-s3.julialang.org/bin/versions.json), and installs -it in ignored `.julia-runtime/`. Packages and caches live in ignored `.julia-depot/`. -It never uses the user's Julia executable, startup file or global environment. -`Project.toml` records direct dependencies; `Manifest.toml` is generated by Julia Pkg. -JuliaCall and PythonCall are pinned together to 0.9.37 for this experiment. -The loader refuses an unprepared checkout and never downloads on import. - -After setup, use `uv run --no-sync` for experiments so optional installed packages -are retained. A plain `uv sync` can remove JuliaCall or a separately installed -native build. Do not import `juliacall` before solprop constructs the backend; -start a fresh Python process when changing runtime, thread or provider settings. -Unset conflicting `PYTHON_JULIACALL_*` or `JULIA_*` overrides if the loader names one. -If the archive checksum fails, remove only the named archive from `.julia-runtime/` -and retry bootstrap; do not bypass verification. Runtime cleanup is confined to -this checkout's `.julia-runtime/` and `.julia-depot/` directories. - -## Start a small Julia/native comparison - -First install the compiler and FFTW prerequisites from the -[native build guide](../docs/guide/performance/building-native.md). Then: - -```sh -uv sync --python 3.14 --extra julia --extra native -PYTHONPATH=. uv run --no-sync python julia/core_compare.py \ - --arms julia/arms-cpu.json --widths 1 4 --rounds 3 --repeats 2 \ - --case rdw:fixed-rk --output .benchmarks/julia-native-rdw -``` - -This is one bounded ten-step case, with one warm-up and six warm samples per -backend/width. Choose a new output directory each time. `arms-cpu.json` uses the -current interpreter's native build and the default Julia BLAS provider with FFTW; -Julia BLAS is explicitly serial, while native keeps the harness's budget policy. -These are controlled configurations, not an assertion that every library uses the -same actual worker count. Inspect `samples.json` and each worker's provenance. -For the optimised Apple Silicon native comparison, follow the -[NEON FFTW build instructions](../docs/guide/performance/building-native.md) and -verify the loaded FFTW/OpenMP paths. A native build using the older Homebrew FFTW -library does not include the codelet improvement measured in the updated ledger. -`differences.json` compares retained final fields; it is not a pass/fail accuracy -certificate. No Numba arm is included in this starter comparison. - -Add `--case ctc:fixed-rk` or `--case radial_filament_256:fixed-rk` when ready. -The large Cartesian cases need much more memory and time; start small. Read -[the ledger](../docs/dev/benchmarks.md#experimental-julia-cpu-prototype) before -comparing timings across machines, providers or observation policies. The tools -below also retain earlier development experiments for reproducibility. - -## Check and measure +# The Julia backend experiment + +**An experiment, not a supported backend. Not for merge.** It asks how fast a compact, +single-source Julia engine can run solprop's routes on a CPU and on an NVIDIA GPU, +against the native backend. [STATUS.md](STATUS.md) holds the design, the measured +results and what is left; the [manual page](../docs/guide/performance/julia.md) says +how to use it. + +`backend="julia"` steps the problem solprop translates, behind the same `StepDriver` +seam as the native backend. The Python front end, the translation, the march's +controller and the output are solprop's own. The engine is the Julia package in +[`src/`](src): + +| File | What | +|---|---| +| `SolpropJulia.jl` | the engine type, construction and its warm-up, the bridge's entry points | +| `launch.jl` | the device layer: every pass a scalar body run by `each!`, `each_column!`, `reduce_each` or `rowsum!`; FFT plans and GEMMs | +| `modal.jl`, `free.jl` | the modal and radial routes, and Cartesian and line free space | +| `responses.jl` | Kerr, one field-plasma channel and one Raman term | +| `dopri.jl`, `rk4.jl`, `adams.jl` | the DOPRI5 trial and commit, SEP 24's RK4IP and SEP 16's exponential Adams | +| `stages.jl` | the longitudinal expansions' stage weights | +| `observe.jl` | what the driver reads between steps: the state, the boundary monitor's and the transverse edge's sums | +| `../ext/SolpropJuliaCUDAExt.jl` | CUDA: the engine's arrays become `CuArray`s | + +## Setting up + +In a source checkout of this branch, with Julia 1.13 (or let the bootstrap download the +checksummed release): ```sh -uv run --no-sync python julia/interop.py -SOLPROP_JULIA_THREADS=4 uv run --no-sync python julia/interop.py -uv run --no-sync pytest tests/backends/test_julia.py -JULIA_DEPOT_PATH="$PWD/.julia-depot" JULIA_LOAD_PATH='@:@stdlib' \ - JULIA_CONDAPKG_BACKEND=Null JULIA_PYTHONCALL_EXE="$PWD/.venv/bin/python" \ - .julia-runtime/julia-1.13.2/bin/julia --startup-file=no --threads=4 \ - --project=julia julia/test/runtests.jl -uv run --no-sync python julia/benchmark.py +uv sync --extra julia +export SOLPROP_JULIA_EXE=$(julia +1.13 -e 'print(joinpath(Sys.BINDIR, "julia"))') +uv run --no-sync python julia/bootstrap.py # --cuda for the GPU environment too ``` -The benchmark runs separate processes at 1, 2, 4 and the physical-core limit, without -duplicate widths. Each of three rounds alternates backend order and takes five warm -repeats. Both backends use FFTW `ESTIMATE`, identical thread limits, FSAL, four or -sixteen modes, and ten prescribed 10 µm steps. It reports construction and first-window -costs separately. Observation and shared host statistics have their own timer. -Generated JSON and field witnesses stay under ignored `.benchmarks/`. -Add `--mode-averaged` to `benchmark.py` or `compare.py` to measure the same pulse and -ten-step window using one amplitude and one effective-area nonlinear node. For a -three-backend Mac comparison: +The bootstrap instantiates `julia/Manifest.toml` into `.julia-depot/` +(`SOLPROP_JULIA_DEPOT` names another). `SOLPROP_JULIA_ROOT` names the checkout when +solprop is installed without `-e`. A run then takes `backend="julia"`: -```sh -uv run --no-sync python julia/compare.py --mode-averaged --blas-threads 1 \ - --arms numba_cpu native julia-accelerate-fftw --output .benchmarks/mode-averaged -``` - -Use `--radial` instead to compare 64- and 256-node axisymmetric Kerr beams at -0.9 critical power in constant argon. Both use the same ten prescribed 10 µm steps, -one or four numerical/FFT threads, and the declared BLAS width. Radial spatial -statistics have their own timer, separate from propagation. The shared Julia -matrix pipeline consumes the translated Hankel maps and the shared spatial-loss -matrix; no new transform package is required. - -Use `--cartesian` for 32×32 and 64×64 Cartesian grids spanning ±500 µm, with the -same pulse, material, time grid and prescribed steps as the radial cases. This path -uses FFTs rather than BLAS contractions. The seam's compact separable operator is -evaluated per stage; a single forward/inverse pair replaces cached stage volumes. -The default spatial statistics are timed separately. On Linux compare -`numba_cpu native julia-openblas-fftw julia-mkl-mkl` to distinguish FFT providers; -changing BLAS alone cannot accelerate this Cartesian propagation path. Add -`--sizes 256` to compare a larger transverse grid at the same time resolution. -Worker records include explicitly owned bytes and peak process resident memory; -the latter also includes frontend arrays, library workspace and temporary copies. - -`--worker julia --profile` additionally writes a Julia sampling profile; provide an -existing output directory and an output JSON path when running a worker directly. - -The numerical core uses native Julia arrays, planned FFTW transforms and BLAS `mul!`. -AcceleratedKernels supplies task scheduling and the generic loop implementation over -KernelAbstractions. A small CPU Kerr traversal shares the scalar product with the -generic loop, but visits contiguous time columns to avoid costly index division. -Constant-table stage propagators are cached for exactly equal step lengths and -rebuilt when an adaptive trial changes the step. CPU pointwise loops traverse -contiguous columns, use SIMD, and require at least 32768 samples per task. -No umbrella fast-math or reassociation of protected reductions is enabled. - -The modal FFT cap is `SOLPROP_FFTW_THREADS`. Raman convolution and transverse -plans accept independent `SOLPROP_JULIA_RAMAN_FFT_THREADS` and -`SOLPROP_TRANSVERSE_FFTW_THREADS` limits. Modal and doubled-grid Raman plans -default to serial below 16384 real-side samples, otherwise up to four workers; -the transverse default follows the modal cap. Mode-averaged BLAS defaults to one -worker. Explicit overrides remain available. Plan widths are -recorded in backend metadata. The kernel-construction FFT is serial and outside -the measured propagation window. - - -`SOLPROP_FFTW_PLAN=estimate|measure|patient` selects Julia's planning effort; -`estimate` remains the experimental default. Measured plans spend additional time -at construction choosing algorithms for the actual array layout and thread count. -Planning is excluded from warm propagation timings and recorded separately. -`julia/compare.py --plan measure` applies the same request to all compared backends. -No FFTW wisdom is imported by this experimental Julia adapter. +| Variable | Meaning | +|---|---| +| `SOLPROP_JULIA_THREADS` | the engine's threads (default 1); the benchmark harness sets it to the width | +| `SOLPROP_JULIA_DEVICE` | `cpu` (default) or `cuda`, which loads `julia/cuda`: CUDA.jl resolved with the engine | +| `SOLPROP_FFTW_PLAN` | `estimate`, `measure` (default) or `patient` | +| `SOLPROP_JULIA_TIMING` | `1`: the engine's section timers (`julia/profile.py` prints them) | +| `SOLPROP_JULIA_CHECK` | `1`: refuse any kernel body a GPU could not take, on any device (the tests set it) | +| `SOLPROP_JULIA_PLASMA` | `samples`: the GPU's per-sample plasma passes on a CPU too | -GPU execution is not implemented or qualified. CUDA/AMDGPU array allocation, FFT plans, -device-safe reductions and synchronization still need adapters and device tests; -the presence of KernelAbstractions/GPUArraysCore in the dependency graph does not -establish GPU support. Metal, Float32, runtime distribution and compilation-cache -engineering remain future work. +A process holds one Julia runtime. Import nothing from `juliacall` before solprop +starts it. -## Provider and compiler experiments +## Measuring -`SOLPROP_JULIA_BLAS=openblas|accelerate|mkl` selects BLAS before constructing the -first backend. AppleAccelerate is the macOS default; other prepared platforms -default to OpenBLAS. AppleAccelerate requires macOS; -MKL is qualified here only on Linux x86_64. Accelerate's threading API selects -single-threaded or library-managed parallel execution, not an exact worker count. -For controlled comparisons set `SOLPROP_BLAS_THREADS=1`. The comparison runner -sets MKL's global and FFT limits to the requested numerical width and its BLAS -domain separately, so `--blas-threads 1` does not cap MKL FFT execution. See -[Intel's domain thread controls](https://www.intel.com/content/www/us/en/docs/onemkl/developer-guide-windows/2025-0/mkl-domain-num-threads.html). - -FFTs remain FFTW independently of BLAS. AppleAccelerate 0.7 also extends AbstractFFTs; -the engine deliberately plans from strided views to retain FFTW plans. To experiment -with MKL FFTs in an isolated checkout, call `FFTW.set_provider!("mkl")` with the private -runtime and project, then restart Python. Restore with `FFTW.set_provider!("fftw")`. -The preference belongs only to that checkout and is not committed. -MKL's FFTW compatibility layer ignores FFTW planning-rigor flags; a recorded -`measure` request is not evidence that MKL performed FFTW's measured search. -See [Intel's FFTW wrapper documentation](https://www.intel.com/content/www/us/en/docs/onemkl/developer-reference-c/2024-1/using-fftw3-wrappers.html). - -`julia/tune.py --compare-blas accelerate --modes 16 --output .benchmarks/blas.json` -alternates providers and Numba in one process after warming. On Linux use -`--compare-blas mkl`. Explicitly set the Julia, Numba, FFT and BLAS thread limits -before launching. `--baseline PATH` also loads a saved numerical module for an -alternating before/after comparison. The runner records source digest, thread -settings, raw timings, source counts and numerical differences, and rejects a -failed rounding screen. It does not establish adaptive accuracy by timing alone. - -The measured compiler settings remain native CPU targeting, normal inlining, `-O2`, -and automatic bounds checking with local `@inbounds` in validated kernels. An -alternating `-O3` experiment did not improve the declared case. LLVM output confirms -packed double-precision SIMD arithmetic in the Kerr loop; protected error reductions -retain their ordered arithmetic. See the benchmark ledger for measured effects. - -The optional `--numba-tabulate` arm checks Numba's tabulated-propagator setting -against its default. On Linux, a mixed Julia/MKL and Numba process can interact with -OpenMP affinity. Use fresh backend processes (`benchmark.py --worker ...`) and -unset `OMP_PLACES` and set `OMP_PROC_BIND=false` for the final comparison; restrict -both processes to the same CPU set externally. Same-process provider sweeps are -useful pilots, but do not replace this isolation check. - -Provider interfaces: [AppleAccelerate](https://github.com/JuliaLinearAlgebra/AppleAccelerate.jl), -[MKL.jl](https://github.com/JuliaLinearAlgebra/MKL.jl), and -[FFTW's provider preference](https://juliamath.github.io/FFTW.jl/stable/). - -For a fresh-process comparison with native and provider attribution, build native in -this checkout, then run: +The benchmark harness takes `julia` as an arm, and `julia32` for it in single precision: ```sh -uv sync --extra native --extra julia -uv run --no-sync python julia/compare.py --blas-threads 1 --output .benchmarks/mac-providers -# Linux: native uses the providers chosen at build time. -uv run --no-sync python julia/compare.py --arms numba_cpu native \ - julia-openblas-fftw julia-mkl-fftw julia-mkl-mkl --output .benchmarks/linux-providers +uv run --no-sync python -m benchmarks ab --baseline-backend native --candidate-backend julia \ + --baseline-python .venv/bin/python --case rdw --threads 1,16 --length 0.02 --noise none ``` -The runner alternates three rounds of five warm windows per arm, at one and four -threads. It records native build information, actual loaded thread pools, NumPy's -BLAS configuration, source counts and final-field witnesses. On macOS both the -installed NumPy/SciPy and native build may already use Accelerate; inspect their -records rather than assuming Numba uses OpenBLAS. `benchmark.py --worker native ---propagator-mode tabulate` records the requested policy, but source inspection -shows that native's resident DOPRI5 path still forms its flows per stage; the -native low-storage integrator has the distinct table option. Removing `SOLPROP_NATIVE_KERNEL_THREADS` and `SOLPROP_NATIVE_FFT_THREADS` -while keeping its global cap exercises native's automatic operation sizing. - -## SEP 30 core cases +`python julia/profile.py PLAN.json ROW...` times one plan row's complete run, warmed, +with `SOLPROP_JULIA_TIMING=1` for the sections or `SOLPROP_JULIA_PROFILE=1` for Julia's +sampling profile. `julia/bench/launch.jl` is the launch-strategy measurement the device +layer rests on. -The scalar CPU subset includes one field-plasma channel, constant scalar Raman, -longitudinal stage expansions and resident exponential Adams. Cartesian envelopes -also execute the existing prescribed RK4IP scheme. Run the frozen core definitions -through the standard harness, including its declared output/statistics windows: +## Testing ```sh -uv run --no-sync python -m benchmarks list --set core --backend julia -uv run --no-sync python -m benchmarks run --set core --backend julia --mode quick -uv run --no-sync python -m benchmarks run --set core --backend julia --track fixed-rk +uv run --no-sync pytest tests/backends/test_julia.py -n 4 # SOLPROP_JULIA_DEVICE=cuda on a GPU ``` -Use the ordinary machine-profile and reference qualification process for publishable -standard comparisons. `core_screen.py` is an additional development tool: it times -propagation only, saves final fields/statistics, and records setup and first-call costs. -Its adaptive timings exclude the standard harness's observations. The focused checks -are in `tests/backends/test_julia_core.py`. Unsupported geometries, response combinations -and integrator variants fail explicitly; see the manual for the scope. - -Cartesian and line field grids also support one scalar plasma channel, including -accepted-field population diagnostics. Their current is evaluated in physical-space -chunks before the transverse forward FFT. Focused source, short DOPRI/RK4IP, -absorber, chunk-tail and memory checks are in -`tests/backends/test_julia_cartesian_plasma.py`. The retained strided FFT layout -uses parallel large copies and inverse normalization, a protected real-root branch, -and omits additive absorber transforms only when their rates are exactly zero. -`tests/backends/test_julia_zero_absorber.py` checks both inactive and active losses. -Exactly zero plasma-rate columns without initial electrons omit current integration -and clear reused outputs. `tests/backends/test_julia_zero_plasma.py` checks reuse -after an ionising source and retention of pre-existing electrons. -Modal and radial sources also skip additive transforms for exactly absent loss -rates; `tests/backends/test_julia_modal_zero_absorber.py` checks active and absent -losses under both temporal schemes. - -The mode-averaged envelope extension executes `gnlse_soliton` and -`gnlse_raman_shock`, using the existing frontend and translated Kerr/Raman/shock -coefficients. Both DOPRI and Adams share the scalar engine. The corresponding -short source, propagation, absorber and reset checks are in -`tests/backends/test_julia_envelope.py`. The long-pulse hydrogen and argon -blueshift mode-averaged field cases use the already supported plasma/Raman path. +Seven focus windows against `numpy_ref`: the same steps, and the field to `1e-10` in +binary64, `1e-4` against the reference's binary32 path. Julia runs bounds-checked there. diff --git a/julia/STATUS.md b/julia/STATUS.md index 4a1e5fe84..993c86942 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -1,222 +1,108 @@ -# Julia experiment: status and handoff - -**Draft experiment — do not merge. CPU only. No CI qualification.** - -This branch demonstrates that Julia can own solprop's numerical backend while the -Python frontend, translation, shared controller and output system remain in use. -It is useful for trying cases, reproducing short timings and continuing development. -It is not ready for production integration or a claim of complete backend parity. -The experiment started from `1df3e4117d7f`, with kernel schema 34. The native CPU -optimisation branch at `75d4fe1` is now merged, including its schema-35 medium-flux -dependency. The adapter passes the new flux plan to shared spatial statistics; -Julia numerical kernels remain unchanged. Qualification of additional medium-flux -capabilities beyond the existing constant-medium spatial cases remains future work. - -Start with the [installation and runnable example](README.md#prepare-a-checkout), -then the [small Julia/native comparison](README.md#start-a-small-julianative-comparison). -The [manual](../docs/guide/performance/julia.md) describes the numerical and thread -contracts. The [benchmark ledger](../docs/dev/benchmarks.md#experimental-julia-cpu-prototype) -contains the measured windows, providers, spreads, correctness evidence and rejected -optimizations, including the final Mac and Xeon comparisons. - -## What works - -| Area | Implemented subset | -|---|---| -| Capillaries | Resolved and mode-averaged scalar field grids, constant radius, separable longitudinal material profiles | -| Mode-averaged envelopes | GNLSE Kerr, constant scalar Raman and translated self-steepening | -| Radial free space | Scalar fields in a constant medium, Kerr and one plasma channel | -| Cartesian and line free space | Scalar Kerr fields/envelopes and one field-plasma channel | -| Responses | Kerr with/without THG on fields; one scalar plasma channel; one constant scalar Raman component on admitted modal/radial routes | -| Integration | DOPRI5 with FSAL; resident exponential Adams on non-Cartesian routes; prescribed RK4IP on Cartesian/line routes | -| Output | Normal save planes, hard masks, both temporal-absorber schemes, default modal/spatial and supported plasma statistics | -| Platforms exercised | Apple Silicon macOS and Linux x86_64, private Julia 1.13.2, Python 3.14 | - -The admission checks explicitly refuse unsupported combinations. In particular: -GPU execution, vector polarization, batching, noise, interpolated planes, tapered -or general modal guides, Cartesian Raman/Adams, resolved/radial envelopes, -envelope plasma/harmonics, multiple plasma/Raman components and advanced -dispersive/regional responses remain outside the experiment. See the manual and -`_refuse` in `src/solprop/backends/julia/_backend.py` for the detailed boundary. -Automatic backend selection is unchanged: request `backend="julia"` explicitly. - -## Implementation size - -Physical source lines, including comments and blank lines, counted on 2026-10-24: - -| Implementation | Numerical code and bindings | Python adapter | Total | -|---|---:|---:|---:| -| Julia prototype | 1,395 | 1,322 | **2,717** | -| Native backend | 24,537 | 4,523 | **29,060** | - -The prototype is approximately **10.7 times smaller by this measure** (90.7% fewer -lines). Julia's numerical column is the six `julia/src/*.jl` files. Native's is all -`.cpp`/`.hpp` under `native/src/` and `native/include/`, except `benchmark_gemm.cpp` -and `coverage_labels.cpp`, plus the `_core.pyi` binding declaration. Python -columns count `src/solprop/backends/julia/*.py` and -`native/src/solprop_native/*.py`, respectively. Tests, documentation, build files, -benchmarks and external dependencies are excluded from both totals. - -This is an implementation-footprint comparison, **not equivalent feature coverage**. -Native has a much larger capability matrix and CPU/CUDA/HIP implementations. Julia -also uses compact formatting, including multiple statements on some lines. Both -reuse solprop's Python frontend and shared driver, and both rely on numerical -libraries. A future matched-capability comparison and readability review would be -more informative than treating this ratio as a language productivity benchmark. - -## Updated Mac comparison after native CPU optimisation - -The native comparison now includes `75d4fe1`, its NEON FFTW build and the shared -schema-35 frontend. Julia numerical kernels are unchanged. The default native LOCAL -compiler policies are retained; library paths and per-operation thread counts were -verified. Six warmed ten-step samples per cell, from three alternating rounds, -give the following propagation medians in seconds: - -| Case | Native, 1 | Julia, 1 | Native, 18 | Julia, 18 | -|---|---:|---:|---:|---:| -| RDW | 0.114971 | 0.162999 | 0.062194 | 0.070273 | -| CtC | 3.781297 | 5.625456 | 2.334840 | 2.201848 | -| Radial filament, 256 nodes | 0.617973 | 0.824063 | 0.299448 | 0.928311 | -| Averaged helium RDW | 0.009504 | 0.017540 | 0.009555 | 0.017701 | -| Resolved argon blueshift | 0.054960 | 0.052243 | 0.020362 | 0.019921 | -| Hydrogen Raman, 6 ps | 0.610981 | 1.105845 | 0.181659 | 0.446256 | -| GNLSE soliton | 0.004863 | 0.006598 | 0.004938 | 0.006619 | -| Averaged argon blueshift | 0.004750 | 0.005199 | 0.004775 | 0.005247 | -| Cartesian 192² × 300 | 8.021165 | 16.110929 | 1.160111 | 2.001772 | -| Cartesian 384² × 600 | 78.224075 | 78.842053 | 10.860181 | 12.629519 | - -Native has taken the serial CtC and H₂ wins, and wins most of the measured cases. -Julia retains the parallel CtC and modest resolved-argon leads. Serial 384² is -effectively tied. Native's lower parallel 384² median has a wide paired range, -including one round where Julia was slightly faster, so its advantage is unresolved -at fine resolution. Host contention interrupted one large-case round; it was -excluded and restarted. Residual host activity remains disclosed in the -[updated ledger](../docs/dev/benchmarks.md#julianative-comparison-after-native-cpu-optimisation), -along with provider/thread settings, spreads, the helper-library audit and separate -setup/observation costs. No fresh Xeon comparison is claimed here. - -## Historical performance before native CPU optimisation - - -Julia is competitive on several realistic CPU cases, but it is not universally -faster than native. The earlier Mac round used an Apple M5 Max with 18 physical cores -and 128 GiB, **native's default Mac build settings**, and Julia with Accelerate -BLAS and FFTW. These are median seconds for ten prescribed steps, six warm samples -per cell from three alternating rounds. Setup, compilation and final observations -are outside these propagation timers; first-window/setup costs were recorded -separately. DOPRI cases use 61 source evaluations; Cartesian RK4IP uses 40. - -| Case | Native 1 thread | Julia 1 thread | Native 18-thread budget | Julia 18-thread budget | -|---|---:|---:|---:|---:| -| RDW | 0.128269 | 0.157036 | 0.070999 | 0.068320 | -| CtC | 6.288408 | 5.325555 | 2.685244 | 2.107181 | -| Radial filament, 256 nodes | 0.649903 | 0.794537 | 0.288600 | 0.855188 | -| Averaged helium RDW | 0.010500 | 0.017543 | 0.010590 | 0.017662 | -| Resolved argon blueshift | 0.056584 | 0.050703 | 0.022913 | 0.019836 | -| Hydrogen Raman, 6 ps | 1.194044 | 1.051791 | 0.243912 | 0.437328 | -| GNLSE soliton | 0.005278 | 0.006534 | 0.005524 | 0.006570 | -| Averaged argon blueshift | 0.005019 | 0.005053 | 0.005156 | 0.005084 | -| Cartesian 192² × 300 | 9.334232 | 15.488092 | 1.217616 | 1.764022 | -| Cartesian 384² × 600 | 89.175180 | 77.226190 | 10.626641 | 11.544229 | - -Julia is 1.27× faster for parallel CtC, 1.15× for parallel resolved argon, and -1.15× for serial large Cartesian propagation. The large Cartesian parallel result -is 8.6% slower than native. Native wins the radial and parallel long-pulse Raman -cases by substantial margins. Radial parallel timings were noisy, but their -ranges remain separated. The ledger records those ranges and the operation-level -FFT/BLAS policies; an 18-thread budget does not force every operation to use 18 -threads. Large Cartesian FFT widths were explicitly set to 18/18. - -The Xeon Gold 6240 results are less favorable: native wins every measured core -window, including the additional modal cases. The comparison explicitly included -GCC 16.2/OpenBLAS and Intel C++/MKL native builds. Neither native bundle wins -everything. On the large Cartesian cases, switching only Julia's FFT provider to -MKL reduced time by roughly 17–19%, with BLAS held fixed, but native remained ahead. -These are hardware/provider/configuration comparisons, not language-wide limits. - -The final Mac field differences were at most 1.65e-15 relative L2 for modal/radial -cases and 8.69e-16 for the large Cartesian cases, with finite fields and matching -work counts. These matched-window comparisons supplement the NumPy-oracle checks; -they do not bound every adaptive propagation's global error. The 384² owned-buffer -ledger is 11.762 GB for Julia versus 7.567 GB for native, excluding runtime, opaque -FFT storage and export temporaries. Memory reduction remains worthwhile. - -## Qualification and publication status - -Development included focused NumPy-reference source/step/short-run comparisons, -rejection/reset and observation-ownership checks, tighter adaptive references, -interop checks and standalone Julia checks. The final combined plasma/absorber -slice passed 57 focused checks on Linux. The schema-35 compatibility update passed -29 focused checks on macOS, including spatial statistics against NumPy. The ledger records earlier stages and -failed or rejected experiments; these counts are not a full-suite certificate. - -**The full Python/native gates, slow lanes and coverage qualification were not run -for this experiment. No tests or gates were run during draft-PR preparation.** -The new runnable example is the existing manual example factored into a script; -the final handoff commands have not been rerun in a fresh clone. Raw runtime caches, -large field witnesses and private campaign directories are not part of the PR. -Public evidence is in the ledger; the committed runners generate new receipts. - -This draft intentionally has no CI qualification. Keep `[skip ci]` in every new -head commit while this policy applies: GitHub uses that marker, not draft status, -to [skip `push`/`pull_request` workflows](https://docs.github.com/en/actions/how-tos/manage-workflow-runs/skip-workflow-runs). -Required checks may remain pending. The -branch's `.readthedocs.yaml` also cancels at checkout with exit code 183, before -dependency installation or documentation generation, using -[Read the Docs' cancellation mechanism](https://docs.readthedocs.com/platform/stable/guides/build/skip-or-cancel-builds.html). -Remove that cancellation and -the skip policy when proposing a reviewed integration. Repository-wide CI and -other branches are unchanged. - -## Next work - -- [ ] **Independent review and integration.** Agree an accepted SEP, review the - protected arithmetic/normalization/ownership contracts, reconcile with current - main, qualify further SEP 34 medium-flux cases, and simplify/format the compact Julia code - for maintainability before any merge proposal. -- [ ] **Reproducible qualification.** Exercise the documented fresh-clone setup on - macOS/Linux; expand NumPy-oracle, adaptive-convergence, state-lifetime and - thread-count checks. Re-enable CI and run the full gates only when integration - is proposed. Assess the shared benchmark-worker changes independently. -- [ ] **NVIDIA GPU implementation and tests.** Add CuArray allocation, device FFTs, - contractions, reductions and synchronization; remove scalar host indexing and - audit transfers across the Python boundary. Start with a small scalar Kerr - capillary, then radial/Cartesian cases; check against NumPy and native before - timing warm device windows, transfers and memory. KernelAbstractions and - AcceleratedKernels dependencies alone do not make this a GPU backend. -- [ ] **AMD GPU implementation and tests.** Add ROCArray/AMDGPU FFT and contraction - support, then repeat the same correctness and bounded performance qualification - on actual hardware. Preserve the common scalar operations where practical. -- [ ] **Operation-sized CPU policies.** Profile radial high-thread regressions and - parallel Raman, including the native Accelerate path. Measure FFTW planning, - layout, task sizes and MKL/OpenBLAS/Accelerate separately. Retain baselines and - stop tuning when repeatable gains disappear; do not enable umbrella fast-math. -- [ ] **Memory and startup.** Reduce large Cartesian resident volumes and copies; - measure allocations, peak RSS and host-statistics/export costs as well as warm - propagation. Investigate Julia precompilation/cache reuse and cold-start cost. -- [ ] **Capability extensions.** Prioritize Cartesian Raman/Adams, resolved/radial - envelopes and envelope plasma, then mixtures/multiple responses, polarization, - batching, noise, tapered/general geometries and interpolated output as needed. - Add each capability with a small reference comparison and a ten-step A/B case. -- [ ] **Distribution.** Design runtime discovery/installation, platform support and - packaging instead of relying on a source-tree-relative private Julia runtime. - Keep explicit failure for unsupported features and preserve automatic selection. -- [ ] **Later precision work.** Establish Float32 error budgets before Metal or other - single-precision GPU work. CPU Float64 measurements do not qualify that path. - -## Code map - -| Path | Role | +# The Julia experiment: status + +An experiment. Draft PR, not for merge; no CI lane runs it. This page records what the +engine is, how fast it is against native on a CPU and on an NVIDIA A40, what it does not +do, and what is left. Measurements are short windows of the benchmark cases (`python -m +benchmarks ab`, ten to two hundred steps); [the ledger](../docs/dev/benchmarks.md#julia-backend-experiment) +has the full rows. + +## What changed from PR #10 + +PR #10 was a CPU-only prototype written against kernel schema 35. This branch carries it +to current main and rewrites the engine: + +- **Main's seam.** No schema number (ADR-068): a digest of the Julia sources, the adapter + and the manifests, checked when the engine loads. `set_initial(resume=)`, the Adams + engine protocol's carrier, hold, restore, observe and snapshot size, stage scalars from + the driver's bundle cache, the general-leaf and carrier-frame refusals, SEP 21's split + collar and SEP 44's transverse edge read through the engine. +- **One source for CPU and GPU, binary64 and binary32.** Every state-sized operation is a + scalar body run by the device layer (`src/launch.jl`); arrays are `Array`s or + `CuArray`s (the CUDA package extension) of `Float64` or `Float32`. The kernel bodies + capture only values and arrays, which `SOLPROP_JULIA_CHECK` enforces on a CPU. +- **Julia 1.13.3**, CUDA.jl 6.5, FFTW.jl, Polyester, KernelAbstractions and + AcceleratedKernels; numba is gone from the tooling, which is now solprop's own harness. + +## What made it fast + +Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless said. + +| Change | Effect | |---|---| -| `julia/src/SolpropJulia.jl` | Typed engine, modal/radial pipeline, transforms, Kerr, DOPRI and state lifecycle | -| `julia/src/responses.jl` | Translated plasma/Raman operations and population diagnostics | -| `julia/src/stages.jl`, `adams.jl` | Stage expansions and resident exponential Adams | -| `julia/src/free.jl`, `rk4.jl` | Cartesian/line transforms and prescribed RK4IP | -| `src/solprop/backends/julia/` | Private runtime, schema admission, shared-driver hooks, memory and observations | -| `julia/Project.toml`, `Manifest.toml`, `bootstrap.py` | Dependencies and checksummed private runtime setup | -| `julia/core_compare.py`, `core_profile.py` | Lightweight standard-case comparisons and profiling | -| `tests/backends/test_julia*.py`, `julia/test/` | Existing focused checks for future contributors to run | - -No native numerical source was changed by the experiment. CPU tuning retained -measured improvements and rejected slower layout/fusion candidates rather than -shipping them as defaults. +| Measure every FFTW plan | a threaded estimated c2r (73728 x 17) took 6.6 ms, measured 1.49 ms | +| Raman: convolve the modal products, not the node drives, where fewer (as native does) | H2 Raman window 10.8 s -> 4.7 s | +| One CPU pool: Polyester tasks for every pass, FFTs as blocks of single-threaded plans, GEMMs as blocks of rows | rdw on four threads 1.10 s -> 0.22 s; Julia's tasks cost 10 us a pass where Polyester's cost 2.2 us | +| Contiguous column loops (`each!`), not a flat index | a flat index's divide made a Kerr pass ten times slower | +| Hold host BLAS to one thread while the engine lives (as native does) | NumPy's spinning OpenBLAS made a radial window 4.3 s against 1.1 s | +| Compile and run every path, and every bridge entry, at construction | 0.6-3.5 s of JIT left the timed window | +| Monitor and edge sums, state copies, in the engine | a Cartesian window's host copies and reductions 1.7 s -> 1.1 s | +| GPU: plasma and observation populations a sample a thread, scans column-wise | A40 rdw plasma 1.23 s -> 0.04 s, argon 4.9 s -> 0.14 s | +| Native's phi-function evaluation (quarter-ulp stop, reciprocals) | radial Adams predictor 0.16 s -> 0.10 s | + +What did not pay: branch-free vectorised `exp` and `log` (1 ulp, and 2x faster than +Base's in isolation) made the plasma's columns slower in place, where the table gather +keeps the loops scalar and Base's cached exponential is cheaper. + +## Where it stands + +Julia's window time over native's, 2 % of each case, both arms in one interpreter, the +same steps and fields equal to rounding (1e-13 or better) unless said. + +**Intel Xeon Gold 6240** (commit `3e2290c0`, socket 1, passive-bound threads): + +| case | 1 thread | 16 threads | +|---|---:|---:| +| rdw | 1.54 | 1.34 | +| argon_blueshift | 2.43 | 2.41 | +| h2_raman_6ps | 1.19 | 1.08 | +| ctc_reduced | 2.67 | 1.42 | +| radial_filament_256 | 1.61 | 3.07 | +| kerr_beam_192 | 1.31 | 3.20 | +| line | 1.39 | 1.81 | + +**NVIDIA A40** against native's CUDA build (commit `90840a43`, binary64): + +| case | ratio | +|---|---:| +| rdw | 1.84 | +| argon_blueshift | 3.43 | +| h2_raman_6ps | 1.33 | +| ctc_reduced | 1.74 | +| radial_filament_256 | 4.35 | +| kerr_beam_192 | 3.62 | +| line | 2.98 | + +The AMD EPYC 7763 and binary32 rows are in the ledger. + +## What is left, measured + +- **Host work per step.** The Adams march, its stage scalars and coefficient tables run in + Python: about 1.2 ms a step on the Xeon (rdw at 16 threads: 0.09 s of engine work in a + 0.23 s window). Native runs the march compiled (SEP 39). A Julia march is the largest + remaining CPU and GPU item. +- **Host statistics per plane.** The saved planes' statistics are the shared host + functions: about 4.6 ms a plane on rdw (12 planes in the window). Native forms them in + its own code. +- **Serial plasma.** The column scans' rate (scalar `log` and `exp` behind an exact + zero-support test), fraction and two running integrals take 0.8 s of argon's 1.2 s + window on one thread; native's vectorised SLEEF calls do the same in less. +- **Binary32 on x86.** It runs (fields 1e-6 from binary64), but slower than binary64: + the scaled field's tails are subnormal, and flush-to-zero is not allowed. GPUs handle + binary32 subnormals at full speed. +- **The A40's binary64.** It runs at 1/64 of its binary32 rate; the A40 says little about + an H200 or an MI325X. + +## Not run + +Vector polarisation, batches, noise, envelope plasma, several plasma channels or Raman +terms, varying Raman, dispersive Kerr, TDSE, planar and general modal guides, tapers, +coupled flows, the interaction Adams formulation, the carrier frame and interpolated +planes are refused by name. + +## Findings for main + +- `parallel_rows` read the CPU topology from sysfs (a file per CPU) before deciding a + pass was too small to thread: 60 ms of a 0.36 s rdw window. Fixed on this branch. +- `benchmarks.worker.timed_run` evaluates `simulation.metadata()` inside the timed + window, and its first evaluation costs about 0.18 s on rdw (the plane bases' modal + identity): the first timed repeat of every arm, native's included, pays it. diff --git a/julia/interop.py b/julia/interop.py deleted file mode 100644 index 0ee05b4bc..000000000 --- a/julia/interop.py +++ /dev/null @@ -1,61 +0,0 @@ -# SPDX-FileCopyrightText: 2026 John C. Travers and contributors -# SPDX-License-Identifier: GPL-3.0-or-later - -"""Exercise the private bridge in a fresh process before numerical qualification.""" - -import gc -import os - -import numpy as np - -from solprop.backends.julia._runtime import call_julia, runtime -from solprop.exceptions import BackendError - - -def main() -> None: - """Check no-GIL threads, owning complex transfers, FFTs and exception causes.""" - runtime() - import juliacall # noqa: PLC0415 - after the isolated runtime is configured - - module = juliacall.newmodule("InteropSmoke") - module.seval(""" - using FFTW, AcceleratedKernels - own(x) = Matrix{ComplexF64}(x) - function threaded(x) - y = similar(x) - AcceleratedKernels.foreachindex(x; max_tasks=Threads.nthreads()) do i - y[i] = 2x[i] - end - y - end - function roundtrip(x) - y = plan_fft(view(x,:,:),1)*x - plan_ifft(view(y,:,:),1)*y - end - fail() = throw(ArgumentError("intentional bridge smoke test")) - """) - original = np.arange(24).reshape(6, 4).astype(complex) * (1 + 0.5j) - owned = module.own(original) - expected = original.copy() - original[:] = 0 - gc.collect() - module.seval("GC.gc()") - np.testing.assert_array_equal(np.asarray(owned), expected) - np.testing.assert_array_equal( - np.asarray(call_julia(module.threaded, owned, nogil=True)), 2 * expected - ) - transformed = np.asarray(call_julia(module.roundtrip, owned, nogil=True)) - # Two length-six transforms: normwise backward error scales with log N. - bound = 32 * np.finfo(float).eps * np.log2(6) * np.linalg.norm(expected) - assert np.linalg.norm(transformed - expected) <= bound - try: - call_julia(module.fail) - except BackendError as error: - assert error.__cause__ is not None and "intentional" in str(error) - else: - raise AssertionError("Julia exception was not translated") - assert os.environ["PYTHON_JULIACALL_HANDLE_SIGNALS"] == "yes" - - -if __name__ == "__main__": - main() diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 526cdf039..6ac016ef5 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -439,7 +439,12 @@ function raman_workspace(c, host, nt, chunk; modes=0, nodes=0, synthesis=nothing end kernel .*= host.real("raman_fraction") # The inverse transform is unnormalised: its 1/(2 nt) is folded into the kernel. + # The spectrum is held as `spectrum * 2^-e`, its largest entry in [1, 2), and the + # response's factor takes 2^e (SEP 33, rule 1: a block exponent): in binary32 the + # kernel's small entries are otherwise subnormal, a 1.7 % error in an H2 window. spectrum = FFTW.rfft(kernel) .* (dt / (2nt)) + e = exponent(maximum(abs, spectrum)) + spectrum .*= exp2(-e) count = modes * (modes + 1) ÷ 2 products = !c.envelope && synthesis !== nothing && nodes >= 2 && count < nodes && count <= chunk columns = products ? count : chunk @@ -456,7 +461,7 @@ function raman_workspace(c, host, nt, chunk; modes=0, nodes=0, synthesis=nothing signal_forward=thg ? nothing : plan(c, plan_fft!, signal, 1), signal_inverse=thg ? nothing : plan(c, plan_bfft!, signal, 1)) end - (kernel=upload(c, C.(spectrum)), factor=host.real("raman_factor"), thg=thg, + (kernel=upload(c, C.(spectrum)), factor=host.real("raman_factor") * exp2(e), thg=thg, products=products, drive=drive, frequency=frequency, extra..., forward=plan(c, plan_rfft, drive, 1; threads=c.raman_fft_threads), inverse=plan(c, plan_brfft, frequency, 2nt, 1; threads=c.raman_fft_threads)) diff --git a/julia/test/runtests.jl b/julia/test/runtests.jl deleted file mode 100644 index b92baafab..000000000 --- a/julia/test/runtests.jl +++ /dev/null @@ -1,101 +0,0 @@ -# SPDX-FileCopyrightText: 2026 John C. Travers and contributors -# SPDX-License-Identifier: GPL-3.0-or-later - -using Test, SolpropJulia, LinearAlgebra -import FFTW -const S = SolpropJulia - -function configuration(tasks) - nw, nm, nt = 5, 2, 16 - # A constant linear problem with the same seven-stage interface; the source - # vanishes, so the analytic exponential is independent of tableau coefficients. - Dict( - "linear" => fill(-0.1 + 0.2im, nw, nm), - "prefactor" => zeros(ComplexF64,nw,nm), - "synthesis" => Matrix{Float64}(I,nm,nm), - "projection" => Matrix{Float64}(I,nm,nm), - "projection_coarse" => Matrix{Float64}(I,nm,nm), - "embedded" => false, "crop" => collect(0:nw-1), - "mask" => [false,true,true,true,false], "norm_mask" => trues(nw), - "weights" => ones(nw), "window" => ones(nt), "omega_window" => ones(nw), - "rate" => zeros(nt), "coarse_rate" => zeros(2(nw-1)), - "a" => zeros(7,7), "b" => zeros(7), "e" => zeros(7), - "c" => collect(range(0,1;length=7)), "factor" => 0.0, - "analytic" => false, "analytic_factor" => 0.0, "split" => false, - "rtol" => 1e-8, "atol" => 1e-14, - "threads" => tasks, "fft_threads" => 1, "blas_threads" => 1, "chunk" => 1, - ) -end - -@testset "filtered prefix, reflected endpoints and overlapping halos" begin - for nt in (9,256), half in (0,2,8) - values=reshape([sin(0.2t)+0.01t for t in 1:2nt],nt,2) - taps=[(-0.2)^k for k in 0:half] - out=similar(values) - for node in 1:2 - x=values[:,node] - extended=vcat(2x[1].-x[half+1:-1:2],x,2x[end].-x[end-1:-1:end-half]) - smooth=[sum(taps[k+1]*(k==0 ? extended[t+half] : - extended[t+half-k]+extended[t+half+k]) for k in 0:half) - for t in 1:nt] - expected=vcat(0.0,cumsum(0.03.*(smooth[1:end-1].+smooth[2:end])./2)) - S.integrate_column!(out,values,node,(taps=taps,dt=0.03)) - # Independent finite convolution and prefix summations: account for - # filter width and every prefix addition, including cancellation. - bound=128eps()*nt*(half+1)*norm(expected) - @test norm(out[:,node]-expected) <= bound - @test out[1,node] == 0 - end - end -end - -@testset "owned state, transforms, masks, rejection and task widths" begin - for tasks in unique([1,Threads.nthreads()]) - engine = S.create(configuration(tasks)) - initial = complex.(reshape(collect(1.0:10.0),5,2), 0.3) - S.load!(engine, initial) - before = S.snapshot(engine) - initial .= 0 - @test any(!iszero,before) - @test all(iszero, before[[1,5],:]) - @test S.trial!(engine, 0.2) == 0 - @test S.snapshot(engine) == before - # Discard the first candidate and try a different step length. - @test S.trial!(engine, 0.1) == 0 - S.commit!(engine, 0.1) - @test S.snapshot(engine) ≈ before .* exp.((-.1+.2im)*.1) rtol=8eps() - @test engine.calls == 13 - @test sum(values(S.ledger(engine))) > 0 - fine = engine.work.fine - fine .= 0 - fine[2:4,:] .= before[2:4,:] - expected = copy(fine) - mul!(engine.work.modal,engine.work.inverse_plan,fine) - mul!(fine,engine.work.forward_plan,engine.work.modal) - # Two length-16 FFTs: a normwise O(eps log N) backward-error budget. - @test norm(fine-expected) <= 32eps()*log2(16)*norm(expected) - S.load!(engine,zeros(ComplexF64,5,2)) - @test S.trial!(engine,0.1) == 0 - S.commit!(engine,0.1) - @test all(iszero,S.snapshot(engine)) - end -end - -@testset "exact zero support retains reflected and prefix conventions" begin - for nt in (9,256), half in (0,2,8), interval in (1:0,1:1,nt:nt,1:nt,3:6) - values=zeros(nt,1) - for t in interval - values[t,1]=cos(0.7t) - end - p=(taps=[(-0.2)^k for k in 0:half],dt=0.03) - out=fill(NaN,nt,1) - # Invoke the retained generic traversal as an independent witness to - # support pruning, including exact zeros and both reflected endpoints. - expected=similar(out) - invoke(S.integrate_column!,Tuple{Any,Any,Any,Any},expected,values,1,p) - S.integrate_column!(out,values,1,p) - bound=128eps()*nt*(half+1)*max(norm(expected),floatmin(Float64)) - @test norm(out-expected) <= bound - @test all(isfinite,out) - end -end diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 4b981ac55..377191ba9 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -111,7 +111,7 @@ def test_julia_reports_its_engine(runtime): @pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") -@pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS[:3] + WINDOWS[4:6]) +@pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS[:6]) def test_julia_single_precision_tracks_the_reference(runtime, case, stepper, fraction): """Binary32 (SEP 33) agrees with the binary32 reference on the same contract. From 348a2d134b41ef4e6dc0769254521b139f1a9a84 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 19:56:33 +0000 Subject: [PATCH 020/107] Julia: frequency-domain synthesis where nodes match modes; real-view GEMMs [skip ci] Radially, where the nodes are as many as the modes, the source is synthesised and projected on the band's rows: each node's spectrum is the modes' times its synthesis row, its analytic signal one inverse transform, and the response and both plasma streams join before one projection. A quarter of the GEMM work and a third fewer transforms; a radial window at 16 Xeon threads 0.86 -> 0.63 s. Complex-by-real products run as real GEMMs on interleaved views: Julia's mixed-type product is generic (slow on a GPU) and, in binary32, wrong when run from several tasks at once (a 1.5 relative error; LinearAlgebra, Julia 1.13.3). Ledger section added. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- docs/dev/benchmarks.md | 50 +++++++++++++++ julia/src/dopri.jl | 16 +++++ julia/src/launch.jl | 14 ++++- julia/src/modal.jl | 137 ++++++++++++++++++++++++++++++++++++++++- julia/src/responses.jl | 9 ++- 5 files changed, 219 insertions(+), 7 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 61c0f0c39..655e15888 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -2902,3 +2902,53 @@ a 768 × 768 × 600 envelope launch through a Sellmeier glass with a Kerr respon A launch's bits don't change, which `tests/test_pulses.py` and `tests/test_cartesian_precision.py` hold across thread counts. The sum that scales the field stays one sum in one order for that reason, so it stays on one thread. + +## Julia backend experiment + +The experimental `julia` backend (`julia/STATUS.md`) against `native`, both arms in one +interpreter, `python -m benchmarks ab --baseline-backend native --candidate-backend julia +--noise none --length 0.02 --stepper default`: 2 % of each case, so ten to two hundred +steps and the cases' 4 to 12 saved planes; the ratio is `julia`/`native`, below one +`julia` faster. Every row took the same steps on both arms, with fields equal to 1e-13 +or better, unless said. These are short windows: they carry the planes' host statistics +and a first-run cost both arms pay (`simulation.metadata()` inside the timed window, +about 0.18 s on `rdw`), and they are not whole runs. + +**Intel Xeon Gold 6240**, 16 cores of socket 1 with their 16 threads, passive-bound +threading, a shared machine (load about 3), two rounds, commit `3e2290c0`: + +| case | native 1 thread, s | julia | ratio | native 16 threads, s | julia | ratio | +|---|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.586 | 0.902 | 1.54 | 0.314 | 0.421 | 1.34 | +| `argon_blueshift` | 0.591 | 1.438 | 2.43 | 0.228 | 0.551 | 2.41 | +| `h2_raman_6ps` | 3.512 | 4.179 | 1.19 | 2.039 | 2.194 | 1.08 | +| `ctc_reduced` | 1.075 | 2.865 | 2.67 | 0.451 | 0.642 | 1.42 | +| `radial_filament_256` | 2.158 | 3.471 | 1.61 | 0.385 | 1.182 | 3.07 | +| `kerr_beam_192` | 5.135 | 6.751 | 1.31 | 0.843 | 2.697 | 3.20 | +| `line` | 0.692 | 0.965 | 1.39 | 0.200 | 0.361 | 1.81 | + +The geometric mean was 2.30 at commit `8ab6c4b9`, before the transverse edge and the +state copies moved into the engine and before the first window's compilation moved to +construction, and 1.78 here. Later commits take a Cartesian 192² window from 1.72 to +1.10 s and a radial one from 0.97 to 0.86 s (single runs, 16 threads, the same socket). + +**NVIDIA A40** (driver 595.71), native's CUDA build (AMPERE86) against `julia` with +`SOLPROP_JULIA_DEVICE=cuda` (CUDA.jl 6.5), `--device`, two rounds, binary64: + +| case | native, s | julia, s at `aa6b9478` | ratio | julia, s at `90840a43` | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.187 | 0.585 | 3.13 | 0.356 | 1.84 | +| `argon_blueshift` | 0.152 | 0.693 | 4.55 | 0.528 | 3.43 | +| `h2_raman_6ps` | 1.127 | 1.501 | 1.33 | 1.515 | 1.33 | +| `ctc_reduced` | 0.266 | | | 0.462 | 1.74 | +| `radial_filament_256` | 0.188 | 0.872 | 4.64 | 0.799 | 4.35 | +| `kerr_beam_192` | 0.203 | 1.513 | 7.47 | 0.662 | 3.62 | +| `line` | 0.112 | 0.354 | 3.19 | 0.325 | 2.98 | + +Between them: the observation populations a sample a thread (they were 70 % of an +`rdw` window's GPU time, one 20 ms kernel a column), the bridge's state copies and an +empty statistics spec's copy. What remains on the A40, from Nsight Systems: binary64 +GEMMs are half of a radial window's device time, the synthesis and projections at +the fine grid's 1728 real rows; FFTs a third of `argon_blueshift`'s, about eight a +source; and host work per step and per plane, which the binary64 kernels do not +explain (`rdw`: 0.14 s on the device in a 0.36 s window). diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index a815989f0..a75e23290 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -160,6 +160,7 @@ end """The embedded coarse quadrature's relative defect in the last stage's source.""" function quadrature_alarm(engine) c, w = engine.config, engine.work + c.spectral && return band_alarm(engine) mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) w.plasma === nothing || add_plasma!(w.coarse_spec, w.plasma, w.forward_plan, c; coarse=true) (; prefactor, omega_window, crop) = c @@ -174,3 +175,18 @@ function quadrature_alarm(engine) end sums[1] == 0 ? NaN : Float64(sqrt(sums[2] / sums[1])) end + +function band_alarm(engine) + c, w = engine.config, engine.work + (; prefactor, omega_window) = c + exact, coarse = w.band_source, w.band_coarse + T = real_type(engine) + sums = reduce_each(.+, (zero(T), zero(T)), c, size(w.y)...) do f, m + @inbounds begin + weight = prefactor[f, m] * omega_window[f] + value = weight * exact[f, m] + (abs2(value), abs2(weight * coarse[f, m] - value)) + end + end + sums[1] == 0 ? NaN : Float64(sqrt(sums[2] / sums[1])) +end diff --git a/julia/src/launch.jl b/julia/src/launch.jl index fbed17b7e..b5d64fb26 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -216,8 +216,17 @@ function Base.:*(p::Blocked, x) x end -"""`C = alpha A B + beta C`: on a CPU, blocks of rows of `C` and `A` as the pool's tasks.""" +"""`C = alpha A B + beta C`: on a CPU, blocks of rows of `C` and `A` as the pool's tasks. + +A complex `C` and `A` against a real `B` are their real views, of twice the rows: one +real GEMM, BLAS's or cuBLAS's. Julia's own mixed-type product is generic, slow on a GPU, +and in binary32 not safe to run from several tasks (a 1.5 relative error on the Xeon, +LinearAlgebra in Julia 1.13.3). +""" function gemm!(C, A, B, alpha, beta, c) + if eltype(C) <: Complex && eltype(A) <: Complex && eltype(B) <: Real + return gemm!(real_rows(C), real_rows(A), B, alpha, beta, c) + end blocks = oncpu(c) ? min(c.tasks, cld(length(C), PARALLEL_SAMPLES ÷ 4)) : 1 blocks <= 1 && return mul!(C, A, B, alpha, beta) rows = cld(size(C, 1), blocks) @@ -228,6 +237,9 @@ function gemm!(C, A, B, alpha, beta, c) C end +"""A column-contiguous complex matrix as the real one of its interleaved parts.""" +real_rows(X) = reshape(reinterpret(real(eltype(X)), X), 2size(X, 1), size(X, 2)) + # Section timers for development: SOLPROP_JULIA_TIMING=1 when the module loads. Off, # `@section` costs one branch. const TIMING = Ref(false) diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 95aa3f4bb..8e93dc889 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -39,9 +39,16 @@ function create_modal(c, host) nn = size(synthesis, 2) chunk = min(host.int("chunk"), nn) R = c.envelope ? C : T + # Synthesis and projection in the frequency domain, on the band's rows (`source_spectral!`), + # where the nodes are about as many as the modes, as radially: half the GEMM rows of + # the fine time grid's, and one projection for the response and both plasma streams. + # Not where the modes are few (a capillary's nodes would add transforms), nor beside + # Raman or an unsplit temporal collar, which read the modes' time signals. + spectral = !c.envelope && !host.flag("raman") && 2nm >= nn && + !(!c.split && any(!iszero, c.rate)) # Every inverse transform is unnormalised: its 1/nt is folded into the tables that # read the time-domain field, the synthesis and the in-stage absorber. - c = merge(c, ( + c = merge(c, (spectral=spectral, spectral_absorber=upload(c, T.(spatial)), # The operator stays binary64 at either precision: propagators and the Adams # flow are formed from it in binary64 and rounded once (SEP 33, 4.1 item 3). linear=upload(c, host.array("linear", ComplexF64)), prefactor=upload(c, host.array("prefactor", C)), @@ -58,7 +65,16 @@ function create_modal(c, host) analytic = dzeros(c, C, nt, chunk) coarse = dzeros(c, R, c.nc, nm) band = dzeros(c, C, nw, nm) + # The spectral path's buffers: a chunk's node spectra on the band and the fine grid, + # its polarisation's, and the band's projected source (and its coarse quadrature's). + node_band = dzeros(c, C, spectral ? nw : 0, spectral ? chunk : 0) + node_fine = dzeros(c, C, spectral ? nf : 0, spectral ? chunk : 0) work = ( + node_band=node_band, node_fine=node_fine, band_source=dzeros(c, C, spectral ? nw : 0, spectral ? nm : 0), + band_coarse=dzeros(c, C, spectral ? nw : 0, spectral ? nm : 0), + node_inverse=spectral ? plan(c, plan_brfft, node_fine, nt, 1) : nothing, + node_forward=spectral ? plan(c, plan_rfft, nodes, 1) : nothing, + absorber_spec_band=dzeros(c, C, spectral && in_stage ? nw : 0, spectral && in_stage ? nm : 0), adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), @@ -66,8 +82,9 @@ function create_modal(c, host) source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), stages=dzeros(c, C, nw, nm, ns), forward=dzeros(c, C, nw, nm, ns), inverse=dzeros(c, C, nw, nm, ns), fine=fine, modal=modal, nodes=nodes, analytic=analytic, - projected=dzeros(c, R, nt, nm), projected_coarse=dzeros(c, R, nt, nm), coarse_spec=similar(fine), - absorber=dzeros(c, R, nt, nm), absorber_spec=similar(fine), coarse=coarse, + projected=dzeros(c, R, nt, spectral ? 0 : nm), projected_coarse=dzeros(c, R, nt, spectral ? 0 : nm), + coarse_spec=similar(fine), absorber=dzeros(c, R, nt, spectral ? 0 : nm), absorber_spec=similar(fine), + coarse=coarse, inverse_plan=c.envelope ? plan(c, plan_bfft, fine, 1) : plan(c, plan_brfft, fine, nt, 1), forward_plan=c.envelope ? plan(c, plan_fft, modal, 1) : plan(c, plan_rfft, modal, 1), analytic_forward=plan(c, plan_fft!, analytic, 1), analytic_inverse=plan(c, plan_bfft!, analytic, 1), @@ -92,6 +109,7 @@ end function source!(engine, lab; quadrature=false) c, w = engine.config, engine.work c.free && return source_free!(engine, lab) + c.spectral && return source_spectral!(engine, lab, quadrature) nm = size(lab, 2) @section :scatter scatter!(w.fine, lab, c) @section :inverse_fft mul!(w.modal, w.inverse_plan, w.fine) @@ -176,6 +194,119 @@ function finish_source!(source, fine, loss, c) end end +"""The source synthesised and projected on the band, chunk by chunk of nodes. + +The same arithmetic as `source!`, reordered: the synthesis and projection are linear +along the modes and the transforms along time, so each node's spectrum is the band's +modes times its synthesis row, and the source's band is the nodes' forward spectra +times the projection. A node's analytic signal is the inverse transform of its doubled +one-sided spectrum, whose real part is its field. The plasma's two streams join each +node's spectrum before the one projection, as in free space. +""" +function source_spectral!(engine, lab, quadrature) + c, w = engine.config, engine.work + (; node_band, node_fine, nodes, analytic, band_source, band_coarse) = w + nt, chunk = size(nodes) + nn = size(c.synthesis, 2) + fill!(band_source, 0) + quadrature && c.embedded && fill!(band_coarse, 0) + (; uncrop, crop) = c + T = real_type(engine) + unit, two, half = one(T), T(2), nt ÷ 2 + for first in 1:chunk:nn + last = min(first + chunk - 1, nn) + count = last - first + 1 + band = @view node_band[:, 1:count] + @section :synthesis gemm!(band, lab, @view(c.synthesis[:, first:last]), true, false, c) + if c.analytic + @section :analytic begin + each!(c, nt, chunk) do k, m + @inbounds begin + f = k <= half + 1 && m <= count ? uncrop[k] : 0 + weight = k == 1 || k == half + 1 ? unit : two + analytic[k, m] = f == 0 ? zero(eltype(analytic)) : weight * node_band[f, m] + end + end + w.analytic_inverse * analytic + each!(c, nt, chunk) do t, m + @inbounds nodes[t, m] = real(analytic[t, m]) + end + end + else + @section :inverse_fft begin + each!(c, size(node_fine)...) do k, m + @inbounds begin + f = m <= count ? uncrop[k] : 0 + node_fine[k, m] = f == 0 ? zero(eltype(node_fine)) : node_band[f, m] + end + end + mul!(nodes, w.node_inverse, node_fine) + end + end + w.plasma === nothing || @section :plasma plasma_current!(w.plasma, nodes, c, count) + @section :kerr nonlinear_nodes!(nodes, c.analytic ? analytic : nodes, c, engine.factor, nothing, count) + @section :forward_fft mul!(node_fine, w.node_forward, nodes) + @section :plasma_spectrum spectral_plasma!(node_band, node_fine, w.plasma, w.node_forward, c) + @section :projection begin + gemm!(band_source, band, @view(c.projection[first:last, :]), true, true, c) + quadrature && c.embedded && + gemm!(band_coarse, band, @view(c.projection_coarse[first:last, :]), true, true, c) + end + end + loss = nothing + if c.in_stage + # The spatial collar is linear and time-independent: its band is the state's + # band times the matrix. The spectral path runs only without a temporal one. + gemm!(w.absorber_spec_band, lab, c.spectral_absorber, true, false, c) + loss = w.absorber_spec_band + end + @section :finish finish_band!(w.source, band_source, loss, c) + engine.calls += 1 + nothing +end + +"""A chunk's band from its nodes' fine spectra, with the plasma streams joined.""" +function spectral_plasma!(band, fine, p, plan, c) + crop = c.crop + if p === nothing + each!(c, size(band)...) do f, m + @inbounds band[f, m] = fine[crop[f], m] + end + return nothing + end + mul!(p.spectrum, plan, p.gated) + mul!(p.edge_spectrum, plan, p.edge) + (; spectrum, edge_spectrum, inverse_omega) = p + mask = c.mask + each!(c, size(band)...) do f, m + @inbounds begin + k = crop[f] + value = fine[k, m] + if mask[f] + inverse = inverse_omega[f] + value += -im * inverse * spectrum[k, m] + inverse^2 * edge_spectrum[k, m] + end + band[f, m] = value + end + end +end + +"""The band's source: the prefactor and the omega window, and an in-stage loss.""" +function finish_band!(source, band, loss, c) + (; prefactor, omega_window, mask) = c + live = loss !== nothing + extra = live ? loss : band + each!(c, size(source)...) do f, m + @inbounds begin + value = prefactor[f, m] * omega_window[f] * band[f, m] + if live && mask[f] + value += extra[f, m] + end + source[f, m] = value + end + end +end + """Observation populations of an accepted state: fractions, peaks and the six maxima.""" function population_snapshot(engine, input) engine.config.free && return population_free_snapshot(engine, input) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 6ac016ef5..7ef05f08a 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -73,7 +73,10 @@ end function plasma_workspace(c, host, nt, chunk, nm, nn) host.flag("plasma") || return nothing T = c.T - columns = c.free ? 0 : nm + # Columns: the chunk's where the streams are transformed node by node (free space, + # the spectral modal path), the modes' where they are projected first. + by_node = c.free || (haskey(c, :spectral) && c.spectral) + columns = by_node ? 0 : nm ( coefficients=upload(c, host.array("plasma_coefficients", T)), # Field range, rate cap, log-table origin and step, charge-mass ratio and @@ -88,8 +91,8 @@ function plasma_workspace(c, host, nt, chunk, nm, nn) gated=dzeros(c, T, nt, chunk), edge=dzeros(c, T, nt, chunk), projected=dzeros(c, T, nt, columns), edge_projected=dzeros(c, T, nt, columns), coarse=dzeros(c, T, nt, columns), coarse_edge=dzeros(c, T, nt, columns), - spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, c.free ? chunk : nm), - edge_spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, c.free ? chunk : nm), + spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, by_node ? chunk : nm), + edge_spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, by_node ? chunk : nm), fractions=dzeros(c, T, nn), peaks=dzeros(c, T, nn), parts=dzeros(c, T, 6, chunk), ) end From e28b730f7cc4b9e46c73e6e7b1f5d5c2c4b7abbd Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 20:09:29 +0000 Subject: [PATCH 021/107] Julia: lint, types, and the registry test's backend list [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/bootstrap.py | 4 +-- julia/profile.py | 11 ++++--- src/solprop/backends/julia/_backend.py | 44 +++++++++++++++----------- src/solprop/backends/julia/_runtime.py | 5 +-- tests/backends/test_julia.py | 2 +- tests/backends/test_registry.py | 5 +-- 6 files changed, 41 insertions(+), 30 deletions(-) diff --git a/julia/bootstrap.py b/julia/bootstrap.py index c89a69f5b..1ff3e1aab 100644 --- a/julia/bootstrap.py +++ b/julia/bootstrap.py @@ -56,7 +56,7 @@ def executable() -> Path: archive = private / name if not archive.is_file(): url = f"https://julialang-s3.julialang.org/bin/{directory}/1.13/{name}" - urllib.request.urlretrieve(url, archive) # noqa: S310 - fixed https URL + urllib.request.urlretrieve(url, archive) with archive.open("rb") as stream: if hashlib.file_digest(stream, "sha256").hexdigest() != expected: raise RuntimeError("Julia archive SHA256 does not match the release") @@ -89,7 +89,7 @@ def main() -> None: env=env, check=True, ) - sys.stdout.write(f"Prepared Julia and julia/Manifest.toml\n") + sys.stdout.write("Prepared Julia and julia/Manifest.toml\n") if __name__ == "__main__": diff --git a/julia/profile.py b/julia/profile.py index 048738674..5de266977 100644 --- a/julia/profile.py +++ b/julia/profile.py @@ -17,6 +17,7 @@ from benchmarks.builders import build from benchmarks.worker import timed_run + from solprop.backends import select from solprop.driver.run import field_retention @@ -36,8 +37,8 @@ def profile(row: dict) -> None: retention = field_retention( problem, simulation.settings.fields, simulation.settings.field_planes ) - timed_run(simulation, problem, engine, retention, simulation._boundary_monitor()) # noqa: SLF001 - jl = engine._jl # noqa: SLF001 + timed_run(simulation, problem, engine, retention, simulation._boundary_monitor()) + jl = engine._jl sampling = os.environ.get("SOLPROP_JULIA_PROFILE") == "1" if sampling: from juliacall import Main # noqa: PLC0415 - after the runtime starts @@ -46,13 +47,13 @@ def profile(row: dict) -> None: Main.seval("Profile.clear(); Profile.start_timer()") jl.clear_timings() record, _ = timed_run( - simulation, problem, engine, retention, simulation._boundary_monitor() # noqa: SLF001 + simulation, problem, engine, retention, simulation._boundary_monitor() ) if sampling: Main.seval("Profile.stop_timer()") Main.seval( - "Profile.print(IOContext(stdout, :displaysize => (200, 220)); format=:flat, " - "sortedby=:count, mincount=20, noisefloor=1)" + "Profile.print(IOContext(stdout, :displaysize => (200, 220)); " + "format=:flat, sortedby=:count, mincount=20, noisefloor=1)" ) times = jl.timings() total = sum(float(times[name]) for name in times) diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 03a2465bd..7f49e3393 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -14,6 +14,7 @@ from jaxtyping import Complex from solprop._helpers import PLAIN +from solprop._process import _BlasLease from solprop.backends.driver import StepDriver, refuse_general_leaves from solprop.backends.exponential import refuse_carrier_frame from solprop.backends.julia._runtime import ( @@ -30,7 +31,6 @@ from solprop.grid import TimeGrid from solprop.modes.protocol import Mode from solprop.monitor import BoundaryEnergies, BoundaryMonitor -from solprop.transverse_monitor import TransverseEdge, _EdgeReading from solprop.noise import NoiseRealisation from solprop.output.schema import SavedPlane from solprop.profiles import ZProfile @@ -48,6 +48,7 @@ from solprop.translate.precision import launch_peak, state_scale from solprop.translate.problem import KernelProblem from solprop.translate.stage import terms +from solprop.transverse_monitor import TransverseEdge, _EdgeReading __all__ = ["JuliaBackend"] @@ -109,12 +110,11 @@ def _refuse(problem: KernelProblem) -> None: Raises ------ BackendError - If a requested leaf is outside the prototype's scope. + If a requested leaf is outside the experiment's scope. """ - response, transform, linear, stepper = ( + response, transform, stepper = ( problem.responses, problem.transform, - problem.linear, problem.stepper, ) reasons = { @@ -211,9 +211,7 @@ def _refuse_stats(spec: StatsSpec, *, spatial: bool = False) -> None: If any requested statistic is unsupported. """ if missing := set(spec.names) - (_SPATIAL_STATS if spatial else _SUPPORTED_STATS): - raise BackendError( - f"julia does not support statistics {sorted(missing)}" - ) + raise BackendError(f"julia does not support statistics {sorted(missing)}") def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: @@ -243,8 +241,6 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: 0.0 if kerr is None else kerr.coefficient * float(density.coefficients[0, 0]) ) control, tableau = problem.stepper.controller, problem.stepper.tableau - chunk = min(transform.node_chunk, transform.n_nodes) - temporal_columns = chunk if transform.kind == "free" else shape[1] # One pool runs every pass, transforms and products included (julia/src/launch.jl): # a transform is split into at most this many blocks of whole columns. fft_threads = thread_limit("SOLPROP_JULIA_FFT_THREADS", threads) @@ -252,7 +248,11 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: # take s**2, the plasma reads the physical field s E (the engine's) and its loss # potential 1 / s**2, and the controller's absolute tolerance is divided by s. single = problem.precision.single - scale = state_scale(launch_peak(problem.initial.field0, problem.grid_kind)) if single else 1.0 + scale = ( + state_scale(launch_peak(problem.initial.field0, problem.grid_kind)) + if single + else 1.0 + ) factor *= scale**2 config: dict[str, object] = { "precision": "single" if single else "double", @@ -367,7 +367,9 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: raman_undamped=raman.undamped.T.copy(), raman_rates=np.array([float(rate(0.0)) for rate in raman.decay_rates]), raman_fraction=raman.fraction, - raman_factor=EPS0 * float((raman.density or responses.density)(0.0)) * scale**2, + raman_factor=EPS0 + * float((raman.density or responses.density)(0.0)) + * scale**2, raman_thg=raman.thg, dt=grids.dt_fine, ) @@ -556,7 +558,7 @@ def _apply_mask( object Opaque Julia engine handle. """ - # A column-major (n_omega, n_modes) view of a contiguous copy: the engine reads it. + # The engine reads a contiguous copy's column-major (n_omega, n_modes) view. values = np.ascontiguousarray(state[0, :, 0, :], dtype=np.complex128) call_julia(self._jl.load_b, self._engine, values.T) self._fsal = False @@ -652,7 +654,9 @@ def _prepare_stages(self, z: float, dz: float) -> None: material = np.array( [ [ - 0.0 if kerr is None else kerr.coefficient * b.kerr_density * self._scale2, + 0.0 + if kerr is None + else kerr.coefficient * b.kerr_density * self._scale2, b.plasma_densities[0] if b.plasma_densities else 0.0, b.preionisation, ] @@ -700,7 +704,9 @@ def _finish(self, state: object, dz: float) -> object: rate = monitor.weights[3] half = power * np.exp(-0.5 * rate * dz) self._split_removed += float(power @ -np.expm1(-rate * dz)) - self._split_found = np.concatenate([[half.sum()], monitor.weights[:3] @ half]) + self._split_found = np.concatenate( + [[half.sum()], monitor.weights[:3] @ half] + ) if self._alarm > 1e-6 and not self._alarm_reported: self._alarm_reported = True logger.warning( @@ -801,8 +807,10 @@ def _edge_reading( return _EdgeReading() tables = reduction.tables count = self._problem.shape[1] - rows = np.arange(count) if full or self._problem.transform.kind == "free" else ( - np.asarray(tables.rows) + rows = ( + np.arange(count) + if full or self._problem.transform.kind == "free" + else (np.asarray(tables.rows)) ) key = (id(reduction), bool(full)) if self._edge_key != key: @@ -1034,7 +1042,7 @@ def close(self) -> None: self._rows.clear() -def _hold_host_blas() -> object | None: +def _hold_host_blas() -> _BlasLease | None: """Hold every host BLAS pool to one thread while the engine lives, as native does. NumPy's OpenBLAS spins after each small host product (the transverse edge's @@ -1044,7 +1052,7 @@ def _hold_host_blas() -> object | None: Returns ------- - object or None + solprop._process._BlasLease or None The lease, or None when no controllable BLAS is loaded. """ import threadpoolctl # noqa: PLC0415 - loaded with the engine only diff --git a/src/solprop/backends/julia/_runtime.py b/src/solprop/backends/julia/_runtime.py index 461e9db26..aaf29f621 100644 --- a/src/solprop/backends/julia/_runtime.py +++ b/src/solprop/backends/julia/_runtime.py @@ -81,8 +81,9 @@ def runtime() -> Any: ``SOLPROP_JULIA_EXE`` names the Julia 1.13 executable (default: the one ``julia/bootstrap.py`` downloads), ``SOLPROP_JULIA_DEPOT`` its package depot - (default ``.julia-depot``) and ``SOLPROP_JULIA_ROOT`` the checkout (`checkout`). ``SOLPROP_JULIA_DEVICE=cuda`` loads CUDA.jl first, so - that the engine's CUDA extension is available. + (default ``.julia-depot``) and ``SOLPROP_JULIA_ROOT`` the checkout (`checkout`). + ``SOLPROP_JULIA_DEVICE=cuda`` loads the CUDA environment, so that the engine's CUDA + extension is available. Returns ------- diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 377191ba9..7cc7247eb 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -14,9 +14,9 @@ import numpy as np import pytest - from benchmarks.builders import build from benchmarks.registry import CASES + from solprop.backends import select from solprop.exceptions import BackendError diff --git a/tests/backends/test_registry.py b/tests/backends/test_registry.py index a4e33c542..effeed954 100644 --- a/tests/backends/test_registry.py +++ b/tests/backends/test_registry.py @@ -186,8 +186,9 @@ def test_an_unknown_name_lists_what_is_usable(linear_problem, narrow_grid): def test_the_table_holds_the_backends_that_exist(): - """The in-tree CUDA backend is gone; mlx is SEP 33's single-precision GPU.""" - assert sorted(BACKENDS) == ["mlx", "native", "numpy_ref"] + """The in-tree CUDA backend is gone; mlx is SEP 33's single-precision GPU; julia + is the Julia backend experiment (julia/STATUS.md).""" + assert sorted(BACKENDS) == ["julia", "mlx", "native", "numpy_ref"] # The tombstone: a removed backend's name is refused wherever a request is validated. From 3969a00c01dcc239227a47c49141446049c69a42 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 20:22:37 +0000 Subject: [PATCH 022/107] benchmarks: the run's record before the clock starts [skip ci] timed_run evaluated simulation.metadata() inside its window; the first evaluation builds the planes' bases, about 0.18 s on rdw, which every arm's first repeat paid. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- benchmarks/worker.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/benchmarks/worker.py b/benchmarks/worker.py index 66894ffe9..a49b9a1ac 100644 --- a/benchmarks/worker.py +++ b/benchmarks/worker.py @@ -226,13 +226,17 @@ def timed_run( engine.set_initial(problem.initial.field0, None, z=problem.initial.z) output = MemoryOutput() + # The run's record before the clock starts: its first evaluation builds the planes' + # bases (about 0.18 s on rdw), which every arm's first repeat would otherwise pay + # inside its window. + metadata = simulation.metadata() before = source_calls(engine) started = time.perf_counter_ns() run_problem( problem, engine, output, - metadata=simulation.metadata(), + metadata=metadata, stats_spec=problem.stats_spec, progress="none", resume_history=simulation.settings.resume_history, From 6d451ca908cec69d9deb9cd58be3f6939bb80d65 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 20:41:35 +0000 Subject: [PATCH 023/107] Julia: Poynting statistics' transforms and observation populations in the engine [skip ci] The saved planes' analytic power and on-axis flux come from the engine's state (poynting), reduced by the reference's own code; the populations read the state the engine holds instead of a host copy. rdw at 16 threads: statistics 55 ms -> 40 ms of the window. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 2 +- julia/src/free.jl | 2 +- julia/src/modal.jl | 9 ++- julia/src/observe.jl | 53 +++++++++++++++ src/solprop/backends/julia/_backend.py | 91 +++++++++++++++++++++++--- tests/backends/test_julia.py | 32 +++++++++ 6 files changed, 175 insertions(+), 14 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 2a59c88d6..6de74b26b 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -114,7 +114,7 @@ function warm!(engine) node_energy(engine) column_energy(engine) w.edge[] = nothing - w.plasma === nothing || population_snapshot(engine, zeros(ComplexF64, size(w.y))) + w.plasma === nothing || population_snapshot(engine, nothing) buffers = (w.y, w.candidate, w.lab, w.source, w.error, w.stages, w.forward, w.inverse) a === nothing || (buffers = (buffers..., a.store, a.states, a.rates, a.moments, a.carried, a.endpoint)) foreach(buffer -> fill!(buffer, 0), buffers) diff --git a/julia/src/free.jl b/julia/src/free.jl index 5a042262b..21f49465a 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -263,7 +263,7 @@ function population_free_snapshot(engine, input) c, w = engine.config, engine.work p = w.plasma (; physical, fine, modal, projected) = w - copyto!(physical, device_matrix(engine, input) .* real_type(engine)(inv(c.scale))) + copyto!(physical, scaled_input(engine, input)) transverse!(physical, w.spatial_inverse, c) chunk, nm = size(modal, 2), size(physical, 2) scale = c.field_scale diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 8e93dc889..eaf5e7a78 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -76,7 +76,7 @@ function create_modal(c, host) node_forward=spectral ? plan(c, plan_rfft, nodes, 1) : nothing, absorber_spec_band=dzeros(c, C, spectral && in_stage ? nw : 0, spectral && in_stage ? nm : 0), adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), - monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), + monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), statistics=Ref{Any}(nothing), raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), @@ -307,12 +307,17 @@ function finish_band!(source, band, loss, c) end end +"""A state given to an observation, at the engine's scale; `nothing` is its own state.""" +scaled_input(engine, ::Nothing) = engine.work.y +scaled_input(engine, input) = + device_matrix(engine, input) .* real_type(engine)(inv(engine.config.scale)) + """Observation populations of an accepted state: fractions, peaks and the six maxima.""" function population_snapshot(engine, input) engine.config.free && return population_free_snapshot(engine, input) c, w = engine.config, engine.work p = w.plasma - scatter!(w.fine, device_matrix(engine, input) .* real_type(engine)(inv(c.scale)), c) + scatter!(w.fine, scaled_input(engine, input), c) mul!(w.modal, w.inverse_plan, w.fine) chunk, nn = size(w.nodes, 2), size(c.synthesis, 2) maxima = zeros(6) diff --git a/julia/src/observe.jl b/julia/src/observe.jl index 39e9d7654..16b991598 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -204,3 +204,56 @@ function edge_energy(engine) nodes[edge.selected] .= Array(out) nodes .* c.scale^2 end + +# --- the Poynting statistics' time-domain power ------------------------------------ + +"""The state's analytic power per mode and its on-axis flux, for the statistics. + +`stats._poynting_statistics`'s transforms: the analytic signals of the state and of +the state times its power weight (`weight`, (n_omega, n_modes)), the cycle-averaged +power `Re(a conj b)` per mode and time, and with `axis` ((2, n_modes)) the on-axis +flux. A field grid's analytic signal keeps the zero-frequency and Nyquist bins once, +as `fourier.analytic_signal` does; an envelope's state already is one. Returns the +power (n_t, n_modes) and the flux (n_t), in the state's physical units. +""" +function poynting(engine, weight, axis) + c, w = engine.config, engine.work + y = w.y + T = real_type(engine) + C = Complex{T} + nw, nm = size(y) + nt = c.nc + s = w.statistics[] + if s === nothing || size(s.signal, 2) != nm + signal, weighted = dzeros(c, C, nt, nm), dzeros(c, C, nt, nm) + s = (signal=signal, weighted=weighted, weight=dzeros(c, T, nw, nm), + inverse=plan(c, plan_bfft!, signal, 1)) + w.statistics[] = s + end + copyto!(s.weight, T.(Matrix{Float64}(weight))) + (; signal, weighted) = s + weights, envelope, nyquist = s.weight, c.envelope, nt ÷ 2 + 1 + unit, two, none = one(T), T(2), zero(C) + for (target, weighting) in ((signal, false), (weighted, true)) + each!(c, nt, nm) do k, m + @inbounds begin + value = k <= nw ? y[k, m] * (weighting ? weights[k, m] : unit) : none + if !envelope + value = k == 1 || k == nyquist ? complex(real(value)) : k < nyquist ? two * value : none + end + target[k, m] = value + end + end + s.inverse * target + end + # Each inverse is unnormalised: numpy's 1/n_t on each signal, and the state scale. + factor = (c.scale / nt)^2 + power = Array(real.(signal .* conj.(weighted))) .* factor + flux = Float64[] + if axis !== nothing + rows = upload(c, T.(Matrix{Float64}(axis))) + electric, magnetic = signal * transpose(rows), weighted * transpose(rows) + flux = vec(sum(Array(real.(electric .* conj.(magnetic))); dims=2)) .* factor + end + (Matrix{Float64}(power), flux) +end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 7f49e3393..c4d88b9cc 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -26,7 +26,7 @@ from solprop.backends.multistep import source_absent from solprop.backends.numpy_ref.passes import plasma_integration_statistics from solprop.backends.spatial import collect_spatial, radial_absorber_matrix -from solprop.constants import EPS0 +from solprop.constants import C, EPS0 from solprop.exceptions import BackendError from solprop.grid import TimeGrid from solprop.modes.protocol import Mode @@ -36,6 +36,7 @@ from solprop.profiles import ZProfile from solprop.stats import ( _POYNTING_STATISTICS, + _power_half_width, StatsSpec, _poynting_statistics, collect, @@ -506,11 +507,7 @@ def _warm_bridge(self) -> None: call_julia(jl.device_name, engine) self._observed_field(engine) if self._problem.flags.has_plasma: - call_julia( - jl.population_snapshot, - engine, - np.zeros((n_omega, n_modes), dtype=np.complex128), - ) + call_julia(jl.population_snapshot, engine, None) call_julia(jl.bind_monitor_b, engine, None, None) self.metadata() @@ -933,22 +930,96 @@ def stats(self, spec: StatsSpec) -> dict[str, np.ndarray]: if self._modes is None: raise BackendError("julia peak_intensity requires modes") axis = self._on_axis_synthesis(self._modes) - values.update(_poynting_statistics(spec, grid, state, self._weight, axis)) + values.update(self._poynting(spec, grid, state, axis)) if "quadrature_error" in spec.names: values["quadrature_error"] = np.asarray(self._alarm) if _SPECIES_STATS.intersection(spec.names): values.update(self._populations(spec, state)) return {name: value[None] for name, value in values.items()} + def _poynting( + self, + spec: StatsSpec, + grid: TimeGrid, + state: np.ndarray, + axis: np.ndarray | None, + ) -> dict[str, np.ndarray]: + """``stats._poynting_statistics`` with its analytic signals formed by the engine. + + The transforms and the on-axis product are the engine's (``poynting``), the + reductions over their short results the reference's own. Windowed statistics + take the host function. + + Parameters + ---------- + spec : solprop.stats.StatsSpec + The requested statistics. + grid : solprop.grid.TimeGrid + The run's grid. + state : numpy.ndarray + The state, (n_modes, n_pol, n_omega), the host copy the plane read. + axis : numpy.ndarray or None + The on-axis synthesis (2, n_modes), for ``peak_intensity``. + + Returns + ------- + dict + The requested Poynting statistics. + """ + names = set(spec.names) & _POYNTING_STATISTICS + if names & {"energy_window", "peak_power_window"}: + return _poynting_statistics(spec, grid, state, self._weight, axis) + values: dict[str, np.ndarray] = {} + density = np.abs(state) ** 2 * self._weight + if "omega0" in names: + total = np.sum(density, axis=-1) + with np.errstate(invalid="ignore", divide="ignore"): + values["omega0"] = np.sum(density * grid.omega, axis=-1) / total + if "energy" in names: + spectral = ( + density + if grid.kind == "envelope" + else density + * np.concatenate(([1.0], np.full(grid.n_omega - 2, 4.0), [1.0])) + ) + values["energy"] = (grid.dt / grid.n_t) * np.sum(spectral, axis=-1) + if names - {"omega0", "energy"}: + wanted = "peak_intensity" in names + power, flux = call_julia( + self._jl.poynting, + self._engine, + np.ascontiguousarray(self._weight[:, 0, :].T), + np.ascontiguousarray(axis) if wanted and axis is not None else None, + ) + power = np.asarray(power).T + total_power = np.sum(power, axis=0) + if "peak_power" in names: + values["peak_power"] = np.max(power, axis=-1) + if "peak_power_total" in names: + values["peak_power_total"] = np.asarray(np.max(total_power)) + for name in ("fwhm_t", "fwhm_t_outer"): + if name in names: + values[name] = _power_half_width( + grid, total_power, outermost=name.endswith("outer") + ) + if wanted: + if axis is None: + msg = "Poynting peak_intensity requires the on-axis synthesis matrix" + raise BackendError(msg) + values["peak_intensity"] = np.asarray( + 0.5 * EPS0 * C * np.max(np.asarray(flux)) + ) + return values + def _populations(self, spec: StatsSpec, state: np.ndarray) -> dict[str, np.ndarray]: """Reduce fresh accepted-field populations at an observation.""" from solprop.backends.populations import population_statistics # noqa: PLC0415 parts = np.zeros(6) if self._problem.flags.has_plasma: - raw = call_julia( - self._jl.population_snapshot, self._engine, state[:, 0, :].T.copy() - ) + # The engine reads the state it holds, which is the one observed. + del state + raw = call_julia(self._jl.population_snapshot, self._engine, None) fractions, peaks = (np.asarray(raw[i], dtype=float)[None] for i in (0, 1)) parts = np.asarray(raw[2], dtype=float) else: diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 7cc7247eb..f41bfe4ed 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -130,3 +130,35 @@ def test_julia_single_precision_tracks_the_reference(runtime, case, stepper, fra # holds two orders in hand and still catches a mis-scaled response (O(1)). scale = float(np.linalg.norm(reference)) assert float(np.linalg.norm(field - reference)) <= 1e-4 * scale + + +def test_julia_poynting_statistics_match_the_host(runtime): + """The engine's analytic signals give the shared host function's statistics.""" + del runtime + from solprop.stats import _poynting_statistics # noqa: PLC0415 + + configuration = CASES["rdw"].configuration( + "default", 2, "julia", fraction=0.002, noise="none" + ) + simulation = build(configuration) + problem = simulation.translate() + engine = select( + "julia", + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(float(configuration["stop"])) + state = engine.observe(field=True).field[0] + axis = engine._on_axis_synthesis(simulation.modes) # noqa: SLF001 + spec = problem.stats_spec + ours = engine._poynting(spec, simulation.grid, state, axis) # noqa: SLF001 + host = _poynting_statistics(spec, simulation.grid, state, engine._weight, axis) # noqa: SLF001 + assert set(ours) == set(host) + for name, value in host.items(): + # The same transforms in another library and order: rounding of the analytic + # signals' sums, far below the 1e-10 the fields are held to. + np.testing.assert_allclose(ours[name], value, rtol=1e-11, atol=0, err_msg=name) + engine.close() From d2d203639b51112c9d18d15c58b79a99664303eb Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 21:01:11 +0000 Subject: [PATCH 024/107] Julia tests: the windows' statistics against the reference's [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- tests/backends/test_julia.py | 38 +++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 9 deletions(-) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index f41bfe4ed..04378ca0a 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -53,8 +53,13 @@ def runtime(): ] +# Statistics that measure rounding: the quadrature's error estimate and the plasma +# column's work balance. +ROUNDING_ESTIMATES = frozenset(("quadrature_error", "plasma_work_defect")) + + def _run(name, configuration): - """Propagate the configured window on one backend; return the field and steps.""" + """Propagate a window on one backend; return its field, steps and statistics.""" simulation = build(configuration | {"backend": name}) problem = simulation.translate() engine = select( @@ -68,8 +73,9 @@ def _run(name, configuration): engine.propagate_to(float(configuration["stop"])) observation = engine.observe(field=True) steps = (observation.n_steps, observation.n_rejected) + statistics = engine.stats(problem.stats_spec) engine.close() - return observation.field, steps + return observation.field, steps, statistics # The Cartesian beam's fused silica is evaluated past Malitson's range, by design of the @@ -82,9 +88,23 @@ def test_julia_matches_the_reference(runtime, case, stepper, fraction): configuration = CASES[case].configuration( stepper, 2, "julia", fraction=fraction, noise="none" ) - field, steps = _run("julia", configuration) - reference, reference_steps = _run("numpy_ref", configuration) + field, steps, statistics = _run("julia", configuration) + reference, reference_steps, reference_statistics = _run("numpy_ref", configuration) assert steps == reference_steps + # The engine forms the Poynting set's transforms and the populations itself: each + # statistic to rounding of its own largest value (a spectrum's tails are rounding). + assert set(statistics) == set(reference_statistics) + for name, value in reference_statistics.items(): + if name in ROUNDING_ESTIMATES: + # A difference of nearly equal sums, at their rounding here (a work defect + # of 1e-13 to 1e-12): two orders of summation agree on its order only. + ours, theirs = float(statistics[name][0]), float(value[0]) + assert ours == theirs or 0.5 <= ours / theirs <= 2.0, (name, ours, theirs) + continue + largest = float(np.max(np.abs(value), initial=0.0)) + np.testing.assert_allclose( + statistics[name], value, rtol=1e-9, atol=1e-9 * largest, err_msg=name + ) # Matched discrete methods on one step sequence: the fields differ by the rounding # of their transforms and sums, which the native/julia A/B measures at <= 1e-13 # over these windows; 1e-10 leaves three orders for longer accumulation and is @@ -123,8 +143,8 @@ def test_julia_single_precision_tracks_the_reference(runtime, case, stepper, fra configuration = CASES[case].configuration( stepper, 2, "julia", fraction=fraction, noise="none" ) | {"precision": "single"} - field, _ = _run("julia", configuration) - reference, _ = _run("numpy_ref", configuration) + field, _, _ = _run("julia", configuration) + reference, _, _ = _run("numpy_ref", configuration) # SEP 33's whole-run field envelope is 1e-3; over these few steps two binary32 # implementations differ by their rounding, ~1e-6 (PR #543's records), so 1e-4 # holds two orders in hand and still catches a mis-scaled response (O(1)). @@ -152,10 +172,10 @@ def test_julia_poynting_statistics_match_the_host(runtime): engine.set_initial(problem.initial.field0, None, z=problem.initial.z) engine.propagate_to(float(configuration["stop"])) state = engine.observe(field=True).field[0] - axis = engine._on_axis_synthesis(simulation.modes) # noqa: SLF001 + axis = engine._on_axis_synthesis(simulation.modes) spec = problem.stats_spec - ours = engine._poynting(spec, simulation.grid, state, axis) # noqa: SLF001 - host = _poynting_statistics(spec, simulation.grid, state, engine._weight, axis) # noqa: SLF001 + ours = engine._poynting(spec, simulation.grid, state, axis) + host = _poynting_statistics(spec, simulation.grid, state, engine._weight, axis) assert set(ours) == set(host) for name, value in host.items(): # The same transforms in another library and order: rounding of the analytic From 09a60bf662c700e1fc3136a052b05e5ebf55c511 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 21:13:19 +0000 Subject: [PATCH 025/107] Julia: its own helpers record, and a trial's tables formed in the engine [skip ci] The stage tables' Chebyshev rows and the Adams basis are the engine's transcriptions (julia/src/helpers.jl, SEP 29 section 6.6), and an Adams trial's coefficient tables are formed in the engine from its nodes, in the shared functions' operations and order: equal to the Python forms bit for bit (tested). rdw at 16 threads on the Xeon: 0.273 s -> 0.214 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 1 + julia/src/helpers.jl | 177 +++++++++++++++++++++ src/solprop/backends/julia/_backend.py | 14 +- src/solprop/backends/julia/_helpers.py | 98 ++++++++++++ src/solprop/backends/julia/_integrators.py | 36 ++--- tests/backends/test_julia.py | 91 +++++++++++ 6 files changed, 389 insertions(+), 28 deletions(-) create mode 100644 julia/src/helpers.jl create mode 100644 src/solprop/backends/julia/_helpers.py diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 6de74b26b..614315883 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -41,6 +41,7 @@ include("free.jl") include("dopri.jl") include("rk4.jl") include("adams.jl") +include("helpers.jl") include("stages.jl") include("observe.jl") diff --git a/julia/src/helpers.jl b/julia/src/helpers.jl new file mode 100644 index 000000000..43d56bd55 --- /dev/null +++ b/julia/src/helpers.jl @@ -0,0 +1,177 @@ +# The shared per-stage and per-step evaluations (`solprop._helpers`), and an exponential +# Adams trial's coefficient tables. Each is a transcription of its Python form with the +# same IEEE operations in the same order (Julia contracts nothing without being asked), +# so the values agree with numpy_ref's and native's bit for bit. + +"""`chebyshev._clenshaw_points`: a table's rows at several positions, written to `out`. + +`c` is (n_intervals, n_terms, n_values) and `out` (n_points, n_values), NumPy arrays +seen through PythonCall. Returns the first position outside `[lower, upper]`, zero +based, or -1. +""" +function clenshaw_points!(z, edges, lower, upper, c, out) + n, m = size(c, 2), size(c, 3) + last = length(edges) - 2 # the last interval, zero based + @inbounds for p in eachindex(z) + zp = z[p] + (zp < lower || zp > upper) && return p - 1 + if zp != zp # NaN sorts last, as in `searchsorted` + k = last + else + # `searchsorted(edges, zp, side="right") - 1`, clamped to an interval. + low, high = 0, length(edges) + while low < high + middle = (low + high) ÷ 2 + if edges[middle+1] <= zp + low = middle + 1 + else + high = middle + end + end + k = min(max(low - 1, 0), last) + end + lo, hi = edges[k+1], edges[k+2] + xp = (2.0 * zp - lo - hi) / (hi - lo) + if n == 1 + for j in 1:m + out[p, j] = c[k+1, 1, j] + 0.0 * xp + end + elseif n == 2 + for j in 1:m + out[p, j] = c[k+1, 1, j] + c[k+1, 2, j] * xp + end + else + x2 = 2 * xp + for j in 1:m + c0, c1 = c[k+1, n-1, j], c[k+1, n, j] + for i in 3:n + tmp = c0 + c0 = c[k+1, n-i+1, j] - c1 + c1 = tmp + c1 * x2 + end + out[p, j] = c0 + c1 * xp + end + end + end + -1 +end + +"""`multistep._basis_rows`: the Lagrange basis on `points`, written to `rows` (its +coefficients, unless integrating) or `weights` (its integrals from 0 to `upper`).""" +function basis_rows!(points, upper, integrate, rows, weights) + n = length(points) + coefficients, product = zeros(n), zeros(n) + @inbounds for index in 1:n + node = points[index] + filled = 1 + coefficients[1] = 1.0 + denominator = 1.0 + for other in 1:n + other == index && continue + root = points[other] + product[1] = 0.0 + for power in 1:filled + product[power+1] = coefficients[power] + end + for power in 1:filled + product[power] -= root * coefficients[power] + end + filled += 1 + for power in 1:filled + coefficients[power] = product[power] + end + denominator *= node - root + end + if integrate + integral = 0.0 + for power in filled:-1:1 + integral = (integral + coefficients[power] / power) * upper + end + weights[index] = integral / denominator + else + for power in 1:filled + rows[index, power] = coefficients[power] / denominator + end + end + end + nothing +end + +"""`stepper.multistep.lagrange_coefficients`, unchecked: (n, n).""" +function lagrange(points) + rows = zeros(length(points), length(points)) + basis_rows!(points, 1.0, false, rows, nothing) + rows +end + +"""`stepper.multistep.integrated_weights` on `[0, 1]`, unchecked: (n,).""" +function integrated(points) + weights = zeros(length(points)) + basis_rows!(points, 1.0, true, nothing, weights) + weights +end + +"""`backends.multistep.factored_defect_rows`, into `rows` ((count, 2 width), zeroed).""" +function factored_defect_rows!(rows, nodes, orders, width) + for (index, order) in enumerate(orders) + points = [1.0; nodes[1:order]] + for (t, node) in enumerate(points) + denominator = 1.0 + for (s, other) in enumerate(points) + s != t && (denominator *= node - other) + end + rows[index, t] = 1.0 / denominator + end + coefficients = [1.0] + for root in nodes[1:order] + product = [0.0; coefficients] + for (power, value) in enumerate(coefficients) + product[power] -= root * value + end + coefficients = product + end + rows[index, width+1:width+order+1] .= coefficients + end + rows +end + +"""An exponential trial's tables (`backends.multistep.trial_tables`) written straight +into the engine's host tables, then copied to the device: `nodes` newest first, the +step's `order` and the `orders` scored, the step's own first; `slots` the history's +zero-based slots and `rate` the operator's rate weights (compensated only).""" +function configure_adams_nodes!(engine, nodes, order, orders, slots, rate) + a = engine.work.adams + h = a.host + nodes, orders = Vector{Float64}(nodes), Vector{Int}(orders) + width, count = 1 + maximum(orders), length(orders) + a.sizes .= (order, width, count) + h.predictor[1:order, 1:order] .= lagrange(nodes[1:order]) + h.corrector[1:width, 1:width] .= 0.0 + h.corrector[1:order+1, 1:order+1] .= lagrange([1.0; nodes[1:order]]) + h.defects[1:count, 1:2width] .= 0.0 + factored_defect_rows!(view(h.defects, 1:count, 1:2width), nodes, orders, width) + incoming = Vector{Int}(slots) + h.slots[1:width-1] .= view(incoming, 1:width-1) .+ 1 + if a.compensated + h.spans[1:width-1] .= 1.0 .- view(nodes, 1:width-1) + # Each count's pair once: the step's own is also its defect's. + weights = Dict(n => (integrated(nodes[1:n]), integrated([1.0; nodes[1:n]])) + for n in unique([order; orders])) + h.cdefects[1:count, 1:width] .= 0.0 + for (index, scored) in enumerate(orders) + predicted, through = weights[scored] + h.cdefects[index, 1:scored+1] .= through + h.cdefects[index, 2:scored+1] .-= predicted + end + predictor, corrector = weights[order] + h.cpredictor[1:order] .= predictor + h.ccorrector[1:order+1] .= corrector + h.rate .= Vector{Float64}(rate) + end + foreach(copyto!, a.device, a.host) + nothing +end + +const clenshaw_points_b = clenshaw_points! +const basis_rows_b = basis_rows! +const configure_adams_nodes_b = configure_adams_nodes! diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index c4d88b9cc..fa081bed0 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -13,10 +13,10 @@ import numpy as np from jaxtyping import Complex -from solprop._helpers import PLAIN from solprop._process import _BlasLease from solprop.backends.driver import StepDriver, refuse_general_leaves from solprop.backends.exponential import refuse_carrier_frame +from solprop.backends.julia._helpers import JULIA from solprop.backends.julia._runtime import ( call_julia, runtime, @@ -26,7 +26,7 @@ from solprop.backends.multistep import source_absent from solprop.backends.numpy_ref.passes import plasma_integration_statistics from solprop.backends.spatial import collect_spatial, radial_absorber_matrix -from solprop.constants import C, EPS0 +from solprop.constants import EPS0, C from solprop.exceptions import BackendError from solprop.grid import TimeGrid from solprop.modes.protocol import Mode @@ -36,8 +36,8 @@ from solprop.profiles import ZProfile from solprop.stats import ( _POYNTING_STATISTICS, - _power_half_width, StatsSpec, + _power_half_width, _poynting_statistics, collect, default_spec, @@ -426,7 +426,7 @@ class JuliaBackend(StepDriver[object]): max_batch = 1 # Shared scalar tables and bookkeeping remain plain Python. Numerical state # and complete propagation trials stay in Julia. - helpers = PLAIN + helpers = JULIA propagator_default = "tabulate" # The transverse edge (SEP 40/44) is read by the driver's host reduction. reads_transverse_edge = True @@ -944,7 +944,7 @@ def _poynting( state: np.ndarray, axis: np.ndarray | None, ) -> dict[str, np.ndarray]: - """``stats._poynting_statistics`` with its analytic signals formed by the engine. + """``stats._poynting_statistics``, its analytic signals formed by the engine. The transforms and the on-axis product are the engine's (``poynting``), the reductions over their short results the reference's own. Windowed statistics @@ -1004,7 +1004,9 @@ def _poynting( ) if wanted: if axis is None: - msg = "Poynting peak_intensity requires the on-axis synthesis matrix" + msg = ( + "Poynting peak_intensity requires the on-axis synthesis matrix" + ) raise BackendError(msg) values["peak_intensity"] = np.asarray( 0.5 * EPS0 * C * np.max(np.asarray(flux)) diff --git a/src/solprop/backends/julia/_helpers.py b/src/solprop/backends/julia/_helpers.py new file mode 100644 index 000000000..9d427b0ee --- /dev/null +++ b/src/solprop/backends/julia/_helpers.py @@ -0,0 +1,98 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The Julia backend's per-stage and per-step evaluations (SEP 29 section 6.6). + +:data:`JULIA` is the backend's record for solprop's shared code: the Chebyshev rows of +the stage tables and the Adams basis, by the engine's transcriptions in +``julia/src/helpers.jl``, which perform the Python forms' operations in their order, +so the values are numpy_ref's bit for bit. A call costs about 17 us against the +Python pass's 100 us. +""" + +import numpy as np + +from solprop._helpers import BasisFunction, Helpers, PointsFunction +from solprop.backends.julia._runtime import runtime + +__all__ = ["JULIA"] + + +def _load_points() -> PointsFunction: + """Return the engine's Chebyshev rows. + + Returns + ------- + collections.abc.Callable + The :data:`solprop._helpers.PointsFunction` of ``clenshaw_points!``. + """ + function = runtime().clenshaw_points_b + + def points( + z: np.ndarray, + edges: np.ndarray, + lower: float, + upper: float, + c: np.ndarray, + out: np.ndarray, + ) -> int: + """Write a table's rows at the positions into `out`; see ``PointsFunction``. + + Parameters + ---------- + z, edges : numpy.ndarray + The positions and the breakpoints, float64. + lower, upper : float + The span with its slack. + c, out : numpy.ndarray + The coefficients and the values, C-contiguous. + + Returns + ------- + int + The first position outside the span, or -1. + """ + return int(function(z, edges, lower, upper, c, out)) + + return points + + +def _load_basis() -> BasisFunction: + """Return the engine's Adams basis. + + Returns + ------- + collections.abc.Callable + The :data:`solprop._helpers.BasisFunction` of ``basis_rows!``. + """ + function = runtime().basis_rows_b + + def basis( + points: np.ndarray, upper: float, integrate: bool + ) -> tuple[np.ndarray, np.ndarray]: + """Return the basis' coefficients or integrals; see ``BasisFunction``. + + Parameters + ---------- + points : numpy.ndarray + The distinct nodes, float64. + upper : float + The integral's upper limit. + integrate : bool + Whether to return the integrals. + + Returns + ------- + tuple + The coefficients ``(n, n)`` and the integrals ``(n,)``. + """ + n = points.shape[0] + rows, weights = np.zeros((n, n)), np.empty(n) + function(points, float(upper), bool(integrate), rows, weights) + return rows, weights + + return basis + + +JULIA = Helpers("julia", _load_points, _load_basis) +"""The Julia engine's record; a trial's tables are formed in the engine itself.""" diff --git a/src/solprop/backends/julia/_integrators.py b/src/solprop/backends/julia/_integrators.py index 98be91096..a175c6c08 100644 --- a/src/solprop/backends/julia/_integrators.py +++ b/src/solprop/backends/julia/_integrators.py @@ -8,11 +8,9 @@ import numpy as np -from solprop._helpers import PLAIN from solprop.backends.julia._backend import JuliaBackend from solprop.backends.julia._runtime import call_julia from solprop.backends.low_storage import schedule_key, table_steps -from solprop.backends.multistep import compensation_tables, exponential_tables from solprop.exceptions import BackendError from solprop.stepper import LowStorageRungeKutta, Multistep from solprop.translate.linop import rate_weights @@ -83,7 +81,7 @@ def start(self, z: float, *, stored: bool) -> None: call_julia( backend._jl.configure_adams_rate_b, backend._engine, - rate_weights(backend._problem.linear, z, helpers=PLAIN), + rate_weights(backend._problem.linear, z, helpers=backend.helpers), ) call_julia(backend._jl.adams_start_b, backend._engine, nogil=True) @@ -133,28 +131,22 @@ def exponential_trial( backend = self.backend if backend._varying: backend._prepare_stages(z, dz) - predictor, corrector, defects = exponential_tables( - nodes, order, orders, helpers=PLAIN - ) - spans = carried = endpoint = corrections = rate = np.empty(0) - if self.compensated: - spans, carried, endpoint, corrections = compensation_tables( - nodes, order, orders, helpers=PLAIN - ) - rate = rate_weights( - backend._problem.linear, z + dz, before=True, helpers=PLAIN + # The tables are formed in the engine (julia/src/helpers.jl), in the shared + # functions' operations and order (backends.multistep.trial_tables). + rate = ( + rate_weights( + backend._problem.linear, z + dz, before=True, helpers=backend.helpers ) + if self.compensated + else np.empty(0) + ) call_julia( - backend._jl.configure_adams_b, + backend._jl.configure_adams_nodes_b, backend._engine, - predictor, - corrector, - defects, - slots[: corrector.shape[0] - 1], - spans, - carried, - endpoint, - corrections, + np.asarray(nodes, dtype=np.float64), + order, + np.asarray(orders, dtype=np.int64), + slots, rate, ) result = call_julia(backend._jl.adams_trial_b, backend._engine, dz, nogil=True) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 04378ca0a..edf3b0157 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -182,3 +182,94 @@ def test_julia_poynting_statistics_match_the_host(runtime): # signals' sums, far below the 1e-10 the fields are held to. np.testing.assert_allclose(ours[name], value, rtol=1e-11, atol=0, err_msg=name) engine.close() + + +def test_julia_helpers_are_the_python_forms_bit_for_bit(runtime): + """The record's Chebyshev rows and Adams basis equal PLAIN's to the last bit.""" + del runtime + from solprop._helpers import PLAIN # noqa: PLC0415 + from solprop.backends.julia._helpers import JULIA # noqa: PLC0415 + + generator = np.random.default_rng(7) + edges = np.cumsum(generator.uniform(0.1, 1.0, 6)) + lower, upper = edges[0] - 1e-12, edges[-1] + 1e-12 + z = np.concatenate([edges, generator.uniform(edges[0], edges[-1], 9), [np.nan]]) + for terms in (1, 2, 3, 17): + for dtype in (np.float64, np.complex128): + c = generator.standard_normal((5, terms, 4)).astype(dtype) + if dtype == np.complex128: + c += 1j * generator.standard_normal(c.shape) + ours, theirs = np.empty((z.size, 4), dtype), np.empty((z.size, 4), dtype) + assert JULIA.points(z, edges, lower, upper, c, ours) == PLAIN.points( + z, edges, lower, upper, c, theirs + ) + np.testing.assert_array_equal(ours, theirs) + outside = np.array([edges[1], edges[-1] + 1.0]) + out = np.empty((2, 4)) + c = generator.standard_normal((5, 3, 4)) + assert JULIA.points(outside, edges, lower, upper, c, out) == 1 + nodes = np.array([0.0, -0.93, -1.81, -2.77, -3.6, -4.55, -5.4]) + for count in range(1, nodes.size + 1): + for upper, integrate in ((1.0, False), (1.0, True), (0.37, True)): + ours = JULIA.basis(np.ascontiguousarray(nodes[:count]), upper, integrate) + theirs = PLAIN.basis(np.ascontiguousarray(nodes[:count]), upper, integrate) + np.testing.assert_array_equal(ours[0], theirs[0]) + if integrate: + np.testing.assert_array_equal(ours[1], theirs[1]) + + +@pytest.mark.parametrize("compensated", [False, True]) +def test_julia_trial_tables_are_the_shared_ones_bit_for_bit(runtime, compensated): + """The engine's own trial tables equal backends.multistep.trial_tables'.""" + from juliacall import Main # noqa: PLC0415 + + from solprop._helpers import PLAIN # noqa: PLC0415 + from solprop.backends.multistep import trial_tables # noqa: PLC0415 + + nodes = [0.0, -0.93, -1.81, -2.77, -3.6, -4.55] + host = Main.seval( + """(configure, nodes, order, orders, compensated) -> begin + sizes = [0, 0, 0] + h = (predictor=zeros(8, 8), corrector=zeros(8, 8), defects=zeros(8, 16), + slots=zeros(Int, 8), spans=zeros(8), cpredictor=zeros(8), + ccorrector=zeros(8), cdefects=zeros(8, 8), rate=zeros(1)) + adams = (host=h, device=h, sizes=sizes, compensated=compensated) + engine = (work=(adams=adams,),) + configure(engine, nodes, order, orders, zeros(Int, 8), [0.5]) + h + end""" + ) + for order, orders in ((3, [3, 2, 4]), (4, [4, 3, 5]), (1, [1, 2])): + h = host( + runtime.configure_adams_nodes_b, + np.asarray(nodes), + order, + np.asarray(orders), + compensated, + ) + shared = trial_tables( + nodes=nodes, + order=order, + orders=orders, + compensated=compensated, + helpers=PLAIN, + ) + width, count = 1 + max(orders), len(orders) + np.testing.assert_array_equal( + np.asarray(h.predictor)[:order, :order], shared[0] + ) + np.testing.assert_array_equal( + np.asarray(h.corrector)[:width, :width], shared[1] + ) + np.testing.assert_array_equal( + np.asarray(h.defects)[:count, : 2 * width], shared[2] + ) + if compensated: + np.testing.assert_array_equal(np.asarray(h.spans)[: width - 1], shared[3]) + np.testing.assert_array_equal(np.asarray(h.cpredictor)[:order], shared[4]) + np.testing.assert_array_equal( + np.asarray(h.ccorrector)[: order + 1], shared[5] + ) + np.testing.assert_array_equal( + np.asarray(h.cdefects)[:count, :width], shared[6] + ) From a8c17f43d959cc90251783616c29cfa2b73a1221 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 21:41:23 +0000 Subject: [PATCH 026/107] Julia: Poynting buffers and plan held by the engine, warmed at construction [skip ci] The analytic signals' buffers, their transform and the power weight are bound once (again only when a varying guide's weight changes), and each plane fills them without allocating: rdw's 12 planes took 13 to 83 ms, collector pauses among them, and now take 10 to 11 ms. The plan is measured at construction rather than inside the first plane. The fixed provenance in metadata() is read from Julia once, not at every plane. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/observe.jl | 88 ++++++++++++++++++-------- src/solprop/backends/julia/_backend.py | 63 ++++++++++++++---- 2 files changed, 112 insertions(+), 39 deletions(-) diff --git a/julia/src/observe.jl b/julia/src/observe.jl index 16b991598..86ba7e0bb 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -207,37 +207,53 @@ end # --- the Poynting statistics' time-domain power ------------------------------------ -"""The state's analytic power per mode and its on-axis flux, for the statistics. - -`stats._poynting_statistics`'s transforms: the analytic signals of the state and of -the state times its power weight (`weight`, (n_omega, n_modes)), the cycle-averaged -power `Re(a conj b)` per mode and time, and with `axis` ((2, n_modes)) the on-axis -flux. A field grid's analytic signal keeps the zero-frequency and Nyquist bins once, -as `fourier.analytic_signal` does; an envelope's state already is one. Returns the -power (n_t, n_modes) and the flux (n_t), in the state's physical units. -""" -function poynting(engine, weight, axis) +"""Hold the Poynting statistics' buffers and their transform, and the power weight +(`weight`, (n_omega, n_modes)) and on-axis rows (`axis`, (2, n_modes), or `nothing`). +A varying guide's weight is bound again at each plane; nothing else changes.""" +function bind_poynting!(engine, weight, axis) c, w = engine.config, engine.work - y = w.y T = real_type(engine) C = Complex{T} - nw, nm = size(y) + nw, nm = size(w.y) nt = c.nc s = w.statistics[] - if s === nothing || size(s.signal, 2) != nm - signal, weighted = dzeros(c, C, nt, nm), dzeros(c, C, nt, nm) - s = (signal=signal, weighted=weighted, weight=dzeros(c, T, nw, nm), - inverse=plan(c, plan_bfft!, signal, 1)) + if s === nothing + signal = dzeros(c, C, nt, nm) + rows = axis === nothing ? nothing : upload(c, T.(permutedims(Matrix{Float64}(axis)))) + width = rows === nothing ? 0 : size(rows, 2) + s = (signal=signal, weighted=dzeros(c, C, nt, nm), weight=dzeros(c, T, nw, nm), + inverse=plan(c, plan_bfft!, signal, 1), rows=rows, + electric=dzeros(c, C, nt, width), magnetic=dzeros(c, C, nt, width), + power=dzeros(c, T, nt, nm), flux=dzeros(c, T, nt), + host_power=zeros(T, nt, nm), host_flux=zeros(T, rows === nothing ? 0 : nt)) w.statistics[] = s end copyto!(s.weight, T.(Matrix{Float64}(weight))) - (; signal, weighted) = s - weights, envelope, nyquist = s.weight, c.envelope, nt ÷ 2 + 1 - unit, two, none = one(T), T(2), zero(C) + nothing +end + +"""The state's analytic power per mode and its on-axis flux, for the statistics. + +`stats._poynting_statistics`'s transforms: the analytic signals of the state and of +the state times its power weight, the cycle-averaged power `Re(a conj b)` per mode and +time, and with `flux` the on-axis flux through the bound rows. A field grid's analytic +signal keeps the zero-frequency and Nyquist bins once, as `fourier.analytic_signal` +does; an envelope's state already is one. Returns host arrays the engine reuses: the +power (n_t, n_modes) and the flux (n_t), in the state's physical units. +""" +function poynting!(engine, flux) + c, w = engine.config, engine.work + y, s = w.y, w.statistics[] + T = real_type(engine) + nw = size(y, 1) + nt, nm = size(s.signal) + (; signal, weighted, weight, power) = s + envelope, nyquist = c.envelope, nt ÷ 2 + 1 + unit, two, none = one(T), T(2), zero(Complex{T}) for (target, weighting) in ((signal, false), (weighted, true)) each!(c, nt, nm) do k, m @inbounds begin - value = k <= nw ? y[k, m] * (weighting ? weights[k, m] : unit) : none + value = k <= nw ? y[k, m] * (weighting ? weight[k, m] : unit) : none if !envelope value = k == 1 || k == nyquist ? complex(real(value)) : k < nyquist ? two * value : none end @@ -247,13 +263,29 @@ function poynting(engine, weight, axis) s.inverse * target end # Each inverse is unnormalised: numpy's 1/n_t on each signal, and the state scale. - factor = (c.scale / nt)^2 - power = Array(real.(signal .* conj.(weighted))) .* factor - flux = Float64[] - if axis !== nothing - rows = upload(c, T.(Matrix{Float64}(axis))) - electric, magnetic = signal * transpose(rows), weighted * transpose(rows) - flux = vec(sum(Array(real.(electric .* conj.(magnetic))); dims=2)) .* factor + factor = T((c.scale / nt)^2) + each!(c, nt, nm) do t, m + @inbounds power[t, m] = real(signal[t, m] * conj(weighted[t, m])) * factor end - (Matrix{Float64}(power), flux) + copyto!(s.host_power, power) + if flux + (; electric, magnetic, rows) = s + gemm!(electric, signal, rows, true, false, c) + gemm!(magnetic, weighted, rows, true, false, c) + values, start = s.flux, zero(T) + each!(c, nt, 1) do t, _ + @inbounds begin + value = start + for j in axes(electric, 2) + value += real(electric[t, j] * conj(magnetic[t, j])) + end + values[t] = value * factor + end + end + copyto!(s.host_flux, values) + end + (s.host_power, s.host_flux) end + +const bind_poynting_b = bind_poynting! +const poynting_b = poynting! diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index fa081bed0..01e1bdf2a 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -449,6 +449,8 @@ def __init__( if str(self._jl.loaded_digest()) != self._digest: raise BackendError("julia sources changed after the runtime loaded them") self._threads = thread_limit("SOLPROP_JULIA_THREADS") + self._fixed: dict[str, object] | None = None + self._poynting_weight: np.ndarray | None = None if not 1 <= self._threads <= int(self._jl.runtime()[1]): raise BackendError("julia thread count must fit the initialized runtime") self._engine = call_julia( @@ -508,6 +510,12 @@ def _warm_bridge(self) -> None: self._observed_field(engine) if self._problem.flags.has_plasma: call_julia(jl.population_snapshot, engine, None) + if self._weight.size: + # The Poynting transforms' plan is measured here, not at the first plane. + axis = None if self._modes is None else self._on_axis_synthesis(self._modes) + self._bind_poynting(axis) + for flux in (False, axis is not None): + np.asarray(call_julia(jl.poynting_b, engine, flux)[0]) call_julia(jl.bind_monitor_b, engine, None, None) self.metadata() @@ -984,14 +992,10 @@ def _poynting( ) values["energy"] = (grid.dt / grid.n_t) * np.sum(spectral, axis=-1) if names - {"omega0", "energy"}: - wanted = "peak_intensity" in names - power, flux = call_julia( - self._jl.poynting, - self._engine, - np.ascontiguousarray(self._weight[:, 0, :].T), - np.ascontiguousarray(axis) if wanted and axis is not None else None, - ) - power = np.asarray(power).T + wanted = "peak_intensity" in names and axis is not None + self._bind_poynting(axis) + power, flux = call_julia(self._jl.poynting_b, self._engine, wanted) + power = np.asarray(power, dtype=np.float64).T total_power = np.sum(power, axis=0) if "peak_power" in names: values["peak_power"] = np.max(power, axis=-1) @@ -1002,7 +1006,7 @@ def _poynting( values[name] = _power_half_width( grid, total_power, outermost=name.endswith("outer") ) - if wanted: + if "peak_intensity" in names: if axis is None: msg = ( "Poynting peak_intensity requires the on-axis synthesis matrix" @@ -1013,6 +1017,24 @@ def _poynting( ) return values + def _bind_poynting(self, axis: np.ndarray | None) -> None: + """Give the engine the power weight, when it is a new one, and the on-axis rows. + + Parameters + ---------- + axis : numpy.ndarray or None + The on-axis synthesis (2, n_modes); bound with the first weight. + """ + if self._poynting_weight is self._weight: + return + call_julia( + self._jl.bind_poynting_b, + self._engine, + np.ascontiguousarray(self._weight[:, 0, :].T), + None if axis is None else np.ascontiguousarray(axis), + ) + self._poynting_weight = self._weight + def _populations(self, spec: StatsSpec, state: np.ndarray) -> dict[str, np.ndarray]: """Reduce fresh accepted-field populations at an observation.""" from solprop.backends.populations import population_statistics # noqa: PLC0415 @@ -1058,14 +1080,32 @@ def metadata(self) -> dict[str, object]: """ self._check_open() assert self._engine is not None + return ( + super().metadata() + | self._provenance() + | {"resident_source_evaluations": int(self._engine.calls)} + ) + + def _provenance(self) -> dict[str, object]: + """Return the engine's fixed provenance, read from Julia once. + + A run records the metadata at every plane; these fields do not change. + + Returns + ------- + dict + The runtime, thread and plan fields of :meth:`metadata`. + """ + if self._fixed is not None: + return self._fixed + assert self._engine is not None version, threads, fft, blas, library = self._jl.runtime() config = self._engine.config free = self._problem.transform.kind == "free" - return super().metadata() | { + self._fixed = { "julia_version": str(version), "julia_source_digest": self._digest, "device": str(self._jl.device_name(self._engine)), - "resident_source_evaluations": int(self._engine.calls), "propagator_cache": ( "schedule_run_mean" if self._low_storage is not None @@ -1089,6 +1129,7 @@ def metadata(self) -> dict[str, object]: "plan_flag": self._plan_flag, "experimental": True, } + return self._fixed def memory_ledger(self) -> dict[str, int]: """List owned numerical arrays, excluding opaque library plan internals. From 9ce6108653e4b643dc3d20b5004f4983a5b9c8f1 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 21:59:28 +0000 Subject: [PATCH 027/107] Julia: stage scalars read by the engine from its own tables [skip ci] A varying problem's scalar tables (the operator's and prefactor's expansion weights, the Kerr and plasma densities, the preionisation) are bound once as PiecewiseChebyshev.packed gives them, and each trial's scalars are formed in one engine call by the transcribed Clenshaw pass: scalars_at's values bit for bit (tested on rdw). rdw at 16 threads: stage preparation 17 ms -> 5 ms, the window 0.214 s -> 0.19 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/stages.jl | 66 +++++++++++++++++++- src/solprop/backends/julia/_backend.py | 84 +++++++++++++++++--------- tests/backends/test_julia.py | 46 ++++++++++++++ 3 files changed, 167 insertions(+), 29 deletions(-) diff --git a/julia/src/stages.jl b/julia/src/stages.jl index a61418b39..f0b8851d1 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -14,7 +14,8 @@ function path_workspace(c, host) (phi=upload(c, phi), prefactor=upload(c, pre), delta=zeros(size(phi, 3), stages), weights=zeros(size(pre, 3), stages), delta_device=dzeros(c, Float64, size(phi, 3), stages), - weights_device=dzeros(c, c.T, size(pre, 3), stages), material=zeros(3, stages)) + weights_device=dzeros(c, c.T, size(pre, 3), stages), material=zeros(3, stages), + tables=Dict{String,Any}(), constants=zeros(4)) end """Take a trial's stage weights: Phi increments, prefactor weights and material scales.""" @@ -66,3 +67,66 @@ function path_propagators!(engine) end end end + +# --- the stage scalars, read by the engine (SEP 39's staged tables) ------------------ + +"""Hold one of the stage's scalar tables as `PiecewiseChebyshev.packed` gives it: +`phi` and `prefactor` (the expansions' weights), `kerr`, `plasma`, `preionisation` +(densities). A name not bound is the constant case `configure_stages_at!` names.""" +bind_stage_table!(engine, name, edges, lower, upper, c) = + (engine.work.path.tables[String(name)] = + (edges=Vector{Float64}(edges), lower=Float64(lower), upper=Float64(upper), + c=Array{Float64,3}(c)); nothing) + +"""Hold the stage's constants: the Kerr coefficient (0 for none), the state scale's +square, and a constant prefactor's span.""" +bind_stage_constants!(engine, kerr, scale2, low, high) = + (engine.work.path.constants .= (kerr, scale2, low, high); nothing) + +"""A bound table's values at the positions, (n_positions, n_values).""" +function stage_values(table, positions) + out = zeros(length(positions), size(table.c, 3)) + bad = clenshaw_points!(positions, table.edges, table.lower, table.upper, table.c, out) + bad >= 0 && throw(ArgumentError( + "z = $(positions[bad+1]) is outside the represented span " * + "[$(table.edges[1]), $(table.edges[end])]")) + out +end + +"""A trial's stage scalars from the bound tables, then `configure_stages!`. + +`translate.stage.scalars_at`'s values for the fields the engine reads, by the same +operations: Phi's increment from `z0` (the distance, for a constant operator), the +prefactor's weights (one, for a constant prefactor, inside its span), and the Kerr +factor, plasma density and preionisation of each position. +""" +function configure_stages_at!(engine, z0, positions) + path = engine.work.path + tables, (kerr, scale2, low, high) = path.tables, path.constants + zs = Vector{Float64}(positions) + n = length(zs) + delta = if haskey(tables, "phi") + here = stage_values(tables["phi"], zs) + permutedims(here .- stage_values(tables["phi"], [Float64(z0)])) + else + reshape([z1 - z0 for z1 in zs], 1, n) + end + weights = if haskey(tables, "prefactor") + permutedims(stage_values(tables["prefactor"], zs)) + else + for z in zs + low <= z <= high || throw(ArgumentError( + "z = $z m lies outside the table, which covers [$low, $high] m")) + end + ones(1, n) + end + column(name) = haskey(tables, name) ? stage_values(tables[name], zs)[:, 1] : zeros(n) + density = column("kerr") + material = permutedims(hcat([kerr * d * scale2 for d in density], + column("plasma"), column("preionisation"))) + configure_stages!(engine, delta, weights, material) +end + +const bind_stage_table_b = bind_stage_table! +const bind_stage_constants_b = bind_stage_constants! +const configure_stages_at_b = configure_stages_at! diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 01e1bdf2a..198d02931 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -463,6 +463,7 @@ def __init__( else 1.0 ) if self._varying: + self._bind_stage_tables() self._prepare_stages(0.0, 0.0) self._plan_flag = os.environ.get("SOLPROP_FFTW_PLAN") or "measure" self._weight = ( @@ -642,43 +643,70 @@ def _trial_step(self, z: float, dz: float) -> tuple[float, object]: return norm, self._engine def _prepare_stages(self, z: float, dz: float) -> None: - """Transfer only the existing seam's scalar bundles before a Julia trial.""" + """Have the engine form a trial's stage scalars from its bound tables. + + Parameters + ---------- + z : float + The trial's anchor, m. + dz : float + Its step, m. + """ problem = self._problem nodes = problem.stepper.tableau.nodes - # Resident Adams reads only the first material row and endpoint flow/ - # material row. Retain the fixed buffer shape without evaluating unused - # DOPRI nodes; repeated positions (including dz=0) share a pure bundle. + # Resident Adams reads only the first material row and the endpoint's; the + # buffer keeps its shape without evaluating the unused DOPRI nodes. offsets = ( [0.0] * (len(nodes) - 1) + [dz] if isinstance(problem.stepper.integrator, Multistep) else [float(c) * dz for c in nodes] ) - self._hoist(z) - bundles = self._stage_bundles(z, [z + offset for offset in offsets]) - kerr = problem.responses.kerr_coefficients - material = np.array( - [ - [ - 0.0 - if kerr is None - else kerr.coefficient * b.kerr_density * self._scale2, - b.plasma_densities[0] if b.plasma_densities else 0.0, - b.preionisation, - ] - for b in bundles - ] - ).T.copy() - deltas, prefactors = [], [] - for bundle in bundles: - assert bundle.phi_delta is not None and bundle.prefactor is not None - deltas.append(bundle.phi_delta) - prefactors.append(bundle.prefactor) call_julia( - self._jl.configure_stages_b, + self._jl.configure_stages_at_b, + self._engine, + z, + np.array([z + offset for offset in offsets]), + ) + + def _bind_stage_tables(self) -> None: + """Give the engine the stage's scalar tables, which it then reads itself. + + The tables ``translate.stage.scalars_at`` reads for the fields the engine takes, + each as :meth:`~solprop.translate.chebyshev.PiecewiseChebyshev.packed` gives + it: the operator's and the prefactor's expansion weights, the Kerr and plasma + densities and the preionisation. A constant operator or prefactor binds no + table. ``julia/src/stages.jl`` evaluates them by the transcribed Clenshaw pass, + so its values are the bundles' bit for bit (tested). + """ + problem = self._problem + linear, responses = problem.linear, problem.responses + tables: dict[str, PiecewiseChebyshev] = {} + if linear.phi_constant is None and linear.separable is None: + assert linear.phi_expansion is not None + tables["phi"] = linear.phi_expansion.weights + if responses.prefactor_constant is None and responses.separable is None: + assert responses.prefactor_expansion is not None + tables["prefactor"] = responses.prefactor_expansion.weights + kerr = responses.kerr_coefficients + if kerr is not None: + tables["kerr"] = responses.density if kerr.density is None else kerr.density + for channel in responses.population_channels[:1]: + tables["plasma"] = channel.density + tables["preionisation"] = channel.preionisation + for name, table in tables.items(): + call_julia(self._jl.bind_stage_table_b, self._engine, name, *table.packed()) + low, high = ( + responses.prefactor_span + if "prefactor" not in tables + else (-math.inf, math.inf) + ) + call_julia( + self._jl.bind_stage_constants_b, self._engine, - np.stack(deltas, axis=1), - np.stack(prefactors, axis=1), - material, + 0.0 if kerr is None else float(kerr.coefficient), + float(self._scale2), + float(low), + float(high), ) def _finish(self, state: object, dz: float) -> object: diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index edf3b0157..649e88eb6 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -273,3 +273,49 @@ def test_julia_trial_tables_are_the_shared_ones_bit_for_bit(runtime, compensated np.testing.assert_array_equal( np.asarray(h.cdefects)[:count, :width], shared[6] ) + + +def test_julia_stage_scalars_are_the_bundles_bit_for_bit(runtime): + """The engine's stage scalars, from its own tables, equal scalars_at's. + + rdw's gas fill varies along the capillary: the operator's and prefactor's + expansions, the Kerr and plasma densities (the focus cases' only varying one). + """ + del runtime + case = "rdw" + from solprop._helpers import PLAIN # noqa: PLC0415 + from solprop.translate.stage import scalars_at # noqa: PLC0415 + + configuration = CASES[case].configuration( + "default", 1, "julia", fraction=0.002, noise="none" + ) + simulation = build(configuration) + problem = simulation.translate() + engine = select("julia", problem, grid=simulation.grid, modes=simulation.modes) + assert engine._varying + span = float(configuration["stop"]) + z, dz = 0.37 * span, 0.21 * span + engine._prepare_stages(z, dz) + path = engine._engine.work.path + count = len(problem.stepper.tableau.nodes) + positions = [z] * (count - 1) + [z + dz] + bundles = scalars_at(problem, z, positions, helpers=PLAIN) + kerr = problem.responses.kerr_coefficients + expected = { + "delta": np.stack([b.phi_delta for b in bundles], axis=1), + "weights": np.stack([b.prefactor for b in bundles], axis=1), + "material": np.array( + [ + [ + 0.0 if kerr is None else kerr.coefficient * b.kerr_density, + b.plasma_densities[0] if b.plasma_densities else 0.0, + b.preionisation, + ] + for b in bundles + ] + ).T, + } + for name, value in expected.items(): + held = np.asarray(getattr(path, name))[:, :count] + np.testing.assert_array_equal(held, value, err_msg=name) + engine.close() From 8b486e15a1c3b1dc74f7796db2d8547454c6a0a0 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 22:36:04 +0000 Subject: [PATCH 028/107] Julia: a plasma column's live samples gathered before their rates [skip ci] The rate is formed in two passes: the samples at zero or the cap are written and the others' indices gathered, then the gathered ones are evaluated with no branch. The carrier takes the field across the table's lower edge twice a cycle, a branch no predictor follows, and each miss discarded a logarithm and an exponential in flight. The same operations per sample (a NaN field stays live): argon's plasma on one thread 0.99 s -> 0.88 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/responses.jl | 47 +++++++++++++++++++++++++++++++++--------- 1 file changed, 37 insertions(+), 10 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 7ef05f08a..e18ac7123 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -87,6 +87,8 @@ function plasma_workspace(c, host, nt, chunk, nm, nn) inverse_omega=upload(c, T.(inv.(host.array("omega", Float64)))), derivative=upload(c, host.array("window_derivative", T)), rate=dzeros(c, T, nt, chunk), fraction=dzeros(c, T, nt, chunk), + # A CPU column's live samples, by index (`exposure_column!`). + live=zeros(Int32, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), integrand=dzeros(c, T, nt, chunk), current=dzeros(c, T, nt, chunk), gated=dzeros(c, T, nt, chunk), edge=dzeros(c, T, nt, chunk), projected=dzeros(c, T, nt, columns), edge_projected=dzeros(c, T, nt, columns), @@ -102,6 +104,10 @@ end x = abs(value) x < lower && return zero(cap) x >= upper && return cap + table_rate(x, table, cap, origin, step) +end +"""The rate inside the table's span, `lower <= x < upper` (or NaN).""" +@inline function table_rate(x, table, cap, origin, step) logarithm = log(x) j = clamp(unsafe_trunc(Int, floor((logarithm - origin) / step)) + 1, 1, size(table, 2)) s = logarithm - (origin + (j - 1) * step) @@ -183,13 +189,34 @@ any one sample's additions. nothing end -"""One column's rates and exposure; return the peak rate.""" -@inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args) - peak = zero(dt) +"""One column's rates and exposure; return the peak rate. + +`scaled_rate` at every sample, in two passes: the samples whose rate is zero or the +cap are written and the others' indices gathered into `live`, then the gathered ones +are evaluated in a loop with no branch. The carrier takes the field across the +table's lower edge twice a cycle, a branch no predictor follows, and each miss +discarded a logarithm and an exponential in flight (2.1 ms -> 0.7 ms of argon's +column pass). Every sample takes the operations it took before; a NaN field is live +and stays NaN. +""" +@inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args, live) + scale, table, lower, upper, cap = args[1], args[2], args[3], args[4], args[5] + origin, step = args[6], args[7] + none = zero(dt) + live_count = 0 @inbounds for t in axes(nodes, 1) - value = scaled_rate(nodes[t, node], args...) - rate[t, node] = value - peak = max(peak, value) + x = abs(scale * nodes[t, node]) + rate[t, node] = x < lower ? none : cap + live[live_count+1, node] = t + live_count += !(x < lower) & !(x >= upper) + end + @inbounds for i in 1:live_count + t = live[i, node] + rate[t, node] = table_rate(abs(scale * nodes[t, node]), table, cap, origin, step) + end + peak = none + @inbounds for t in axes(nodes, 1) + peak = max(peak, rate[t, node]) end integrate_column!(exposure, rate, node, taps, dt) peak @@ -259,7 +286,7 @@ end function plasma_columns!(p, nodes, c, count) T = typeof(p.dt) - (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative) = p + (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative, live) = p window, floor = c.window, p.floor args = rate_arguments(p) charge, potential = T(p.parameters[6]), T(p.parameters[7]) @@ -267,7 +294,7 @@ function plasma_columns!(p, nodes, c, count) nt = size(nodes, 1) none, nan = zero(T), T(NaN) each_column!(c, count) do node - peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args) + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live) # With exactly zero rates and no initial electrons both currents vanish. if iszero(peak) && iszero(initial) @inbounds for t in 1:nt @@ -380,13 +407,13 @@ end function population_columns!(p, nodes, c, first, count) T = typeof(p.dt) - (; rate, fraction, taps, dt, fractions, peaks, parts) = p + (; rate, fraction, taps, dt, fractions, peaks, parts, live) = p floor, args = p.floor, rate_arguments(p) initial = T(p.parameters[9]) nt, reach = size(nodes, 1), 2 * (length(taps) - 1) none = zero(T) each_column!(c, count) do node - peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args) + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live) dip = rise = paid = early = largest = none before = product_before = start = none @inbounds for t in 1:nt From db370cf75cb95e038473d83afbb36216f2a80a73 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 22:59:59 +0000 Subject: [PATCH 029/107] Julia: vectorised exp and log for the CPU's plasma columns [skip ci] julia/src/vmath.jl: branch-free binary64 exp and log, each within one ulp of the correctly rounded value (Cody-Waite reduction, Taylor polynomials, explicit fused steps; the role of native's vmath.hpp and SLEEF), which a CPU vectorises under AVX2 as under AVX-512. A column's live rates run as three passes (vectorised log, the table's lookup, vectorised exp), its fractions and currents as vectorised passes of their own, behind function barriers: argon's plasma on one thread 4.7 ms -> 2.9 ms a source. The GPU and the observation populations keep Base's functions. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 1 + julia/src/responses.jl | 105 ++++++++++++++++++++++------------- julia/src/vmath.jl | 60 ++++++++++++++++++++ tests/backends/test_julia.py | 30 ++++++++++ 4 files changed, 156 insertions(+), 40 deletions(-) create mode 100644 julia/src/vmath.jl diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 614315883..07a96696a 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -35,6 +35,7 @@ mutable struct Engine{C,W} end include("launch.jl") +include("vmath.jl") include("responses.jl") include("modal.jl") include("free.jl") diff --git a/julia/src/responses.jl b/julia/src/responses.jl index e18ac7123..39d9042e4 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -87,8 +87,9 @@ function plasma_workspace(c, host, nt, chunk, nm, nn) inverse_omega=upload(c, T.(inv.(host.array("omega", Float64)))), derivative=upload(c, host.array("window_derivative", T)), rate=dzeros(c, T, nt, chunk), fraction=dzeros(c, T, nt, chunk), - # A CPU column's live samples, by index (`exposure_column!`). + # A CPU column's live samples, by index, and their fields (`exposure_column!`). live=zeros(Int32, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), + scratch=zeros(T, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), integrand=dzeros(c, T, nt, chunk), current=dzeros(c, T, nt, chunk), gated=dzeros(c, T, nt, chunk), edge=dzeros(c, T, nt, chunk), projected=dzeros(c, T, nt, columns), edge_projected=dzeros(c, T, nt, columns), @@ -106,13 +107,53 @@ end x >= upper && return cap table_rate(x, table, cap, origin, step) end +# The vectorised passes are functions of their own: inside a column's closure the +# loops stayed scalar. The table's lookup is a pass between them, since a gather keeps +# LLVM from vectorising a loop: argon's live rates 39 ns a sample -> 10 ns. +@noinline function live_rates!(scratch, node, count, table, cap, origin, step) + @inbounds @simd for i in 1:count + scratch[i, node] = vlog(scratch[i, node]) + end + @inbounds for i in 1:count + scratch[i, node] = log_rate(scratch[i, node], table, origin, step) + end + @inbounds @simd for i in 1:count + scratch[i, node] = min(vexp(scratch[i, node]), cap) + end +end +"""Every sample's fraction and the free current's integrand, vectorised (`vexp`).""" +@noinline function fraction_column!(fraction, integrand, nodes, node, initial, charge, floor) + none = zero(initial) + @inbounds @simd for t in axes(nodes, 1) + exposure = floor ? max(fraction[t, node], none) : fraction[t, node] + value = 1 - (1 - initial) * vexp(-exposure) + fraction[t, node] = value + integrand[t, node] = value * charge * nodes[t, node] + end +end +"""The gated and edge currents of a column: the free current plus the loss current, +formed everywhere and kept where the rate and the field are live.""" +@noinline function currents_column!(gated, edge, nodes, rate, fraction, current, window, + derivative, node, potential, density) + none = zero(potential) + @inbounds @simd for t in axes(nodes, 1) + field, value = nodes[t, node], rate[t, node] + squared = field * field + loss = ifelse((value > 0) & (squared > 0), + (potential * value * (1 - fraction[t, node]) / squared) * field, none) + total = density * (current[t, node] + loss) + gated[t, node] = window[t] * total + edge[t, node] = derivative[t] * total + end +end """The rate inside the table's span, `lower <= x < upper` (or NaN).""" -@inline function table_rate(x, table, cap, origin, step) - logarithm = log(x) +@inline table_rate(x, table, cap, origin, step) = + min(exp(log_rate(log(x), table, origin, step)), cap) +"""The table's `log W` at `log |E|`: the knot's cubic in the distance past it.""" +@inline function log_rate(logarithm, table, origin, step) j = clamp(unsafe_trunc(Int, floor((logarithm - origin) / step)) + 1, 1, size(table, 2)) s = logarithm - (origin + (j - 1) * step) - @inbounds value = ((table[1, j] * s + table[2, j]) * s + table[3, j]) * s + table[4, j] - min(exp(value), cap) + @inbounds ((table[1, j] * s + table[2, j]) * s + table[3, j]) * s + table[4, j] end @inline rate_arguments(p) = (p.field_scale, p.coefficients, ntuple(k -> typeof(p.dt)(p.parameters[k]), 5)...) @@ -191,15 +232,16 @@ end """One column's rates and exposure; return the peak rate. -`scaled_rate` at every sample, in two passes: the samples whose rate is zero or the -cap are written and the others' indices gathered into `live`, then the gathered ones -are evaluated in a loop with no branch. The carrier takes the field across the -table's lower edge twice a cycle, a branch no predictor follows, and each miss -discarded a logarithm and an exponential in flight (2.1 ms -> 0.7 ms of argon's -column pass). Every sample takes the operations it took before; a NaN field is live +`scaled_rate` at every sample, in three passes: the samples whose rate is zero or the +cap are written and the others gathered (their index into `live`, their field into +`scratch`); the gathered ones are evaluated in a loop the CPU vectorises, with +`vlog` and `vexp`; and scattered back. The carrier takes the field across the +table's lower edge twice a cycle, a branch no predictor follows, which kept the +logarithm and exponential scalar and discarded them in flight (argon's rates 2.1 ms +-> 0.7 ms a source on one thread, its plasma 4.7 ms -> 2.9 ms). A NaN field is live and stays NaN. """ -@inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args, live) +@inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args, live, scratch) scale, table, lower, upper, cap = args[1], args[2], args[3], args[4], args[5] origin, step = args[6], args[7] none = zero(dt) @@ -208,11 +250,12 @@ and stays NaN. x = abs(scale * nodes[t, node]) rate[t, node] = x < lower ? none : cap live[live_count+1, node] = t + scratch[live_count+1, node] = x live_count += !(x < lower) & !(x >= upper) end + live_rates!(scratch, node, live_count, table, cap, origin, step) @inbounds for i in 1:live_count - t = live[i, node] - rate[t, node] = table_rate(abs(scale * nodes[t, node]), table, cap, origin, step) + rate[live[i, node], node] = scratch[i, node] end peak = none @inbounds for t in axes(nodes, 1) @@ -286,15 +329,15 @@ end function plasma_columns!(p, nodes, c, count) T = typeof(p.dt) - (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative, live) = p + (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative, live, scratch) = p window, floor = c.window, p.floor args = rate_arguments(p) charge, potential = T(p.parameters[6]), T(p.parameters[7]) density, initial = T(p.parameters[8]), T(p.parameters[9]) nt = size(nodes, 1) - none, nan = zero(T), T(NaN) + none = zero(T) each_column!(c, count) do node - peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live) + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch) # With exactly zero rates and no initial electrons both currents vanish. if iszero(peak) && iszero(initial) @inbounds for t in 1:nt @@ -303,28 +346,10 @@ function plasma_columns!(p, nodes, c, count) end return nothing end - previous, value = nan, none - @inbounds for t in 1:nt - exposure = floor ? max(fraction[t, node], none) : fraction[t, node] - # An unchanged prefix gives the same fraction: the zero-rate head and the - # constant tail cost no exponential. No threshold, no approximation. - if exposure != previous - value = 1 - (1 - initial) * exp(-exposure) - previous = exposure - end - fraction[t, node] = value - integrand[t, node] = value * charge * nodes[t, node] - end + fraction_column!(fraction, integrand, nodes, node, initial, charge, floor) integrate_column!(current, integrand, node, taps, dt) - @inbounds for t in 1:nt - field = nodes[t, node] - squared = field * field - loss = rate[t, node] > 0 && squared > 0 ? - (potential * rate[t, node] * (1 - fraction[t, node]) / squared) * field : none - total = density * (current[t, node] + loss) - gated[t, node] = window[t] * total - edge[t, node] = derivative[t] * total - end + currents_column!(gated, edge, nodes, rate, fraction, current, window, derivative, + node, potential, density) nothing end end @@ -407,13 +432,13 @@ end function population_columns!(p, nodes, c, first, count) T = typeof(p.dt) - (; rate, fraction, taps, dt, fractions, peaks, parts, live) = p + (; rate, fraction, taps, dt, fractions, peaks, parts, live, scratch) = p floor, args = p.floor, rate_arguments(p) initial = T(p.parameters[9]) nt, reach = size(nodes, 1), 2 * (length(taps) - 1) none = zero(T) each_column!(c, count) do node - peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live) + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch) dip = rise = paid = early = largest = none before = product_before = start = none @inbounds for t in 1:nt diff --git a/julia/src/vmath.jl b/julia/src/vmath.jl new file mode 100644 index 000000000..f651966a7 --- /dev/null +++ b/julia/src/vmath.jl @@ -0,0 +1,60 @@ +# Branch-free binary64 `exp` and `log` for loops a CPU vectorises (native's vmath.hpp +# role, ADR-059): each within one ulp of the correctly rounded value on the domain +# below, by Cody-Waite reduction and Taylor polynomials evaluated with explicit +# fused multiply-adds (a library function's own error bound, SEP 25; no fast-math). +# Integers are formed by the 1.5 * 2^52 shift, so AVX2 (no 64-bit conversions) +# vectorises them as well as AVX-512. Other precisions take Base's functions. + +const SHIFT = 6.755399441055744e15 # 1.5 * 2^52: x + SHIFT holds round(x) in its low bits +const INV_LN2 = 1.4426950408889634 +const LN2_HI = 6.93147180369123816490e-01 # ln 2, its low 21 bits zero: n LN2_HI is exact +const LN2_LO = 1.90821492927058770002e-10 +const ONE_BITS = reinterpret(Int64, 1.0) +const SQRT_HALF_BITS = Int64(0x3fe6a09e) << 32 # just below sqrt(1/2)'s bits +const MANTISSA = Int64(0x000fffffffffffff) + +"""Horner's rule with fused steps, `p r + c` for each coefficient in turn, unrolled.""" +@inline horner(r, p, c::Tuple) = horner(r, fma(p, r, first(c)), Base.tail(c)) +@inline horner(r, p, ::Tuple{}) = p + +"""2^q for an integer-valued q in [-1022, 1023], from its bits.""" +@inline pow2(q::Int64) = reinterpret(Float64, (q + 1023) << 52) + +"""`exp(x)`, branch-free; any binary64, NaN to NaN, overflow to Inf, underflow to 0.""" +@inline function vexp(x::Float64) + x = clamp(x, -1000.0, 1000.0) + shifted = fma(x, INV_LN2, SHIFT) + q = reinterpret(Int64, shifted) - reinterpret(Int64, SHIFT) + n = shifted - SHIFT + r = fma(n, -LN2_HI, x) + r = fma(n, -LN2_LO, r) + # exp(r) - 1 - r on |r| <= ln2 / 2 by Taylor's series to r^13 (remainder < 2^-60). + p = horner(r, 1 / 6227020800, (1 / 479001600, 1 / 39916800, 1 / 3628800, 1 / 362880, + 1 / 40320, 1 / 5040, 1 / 720, 1 / 120, 1 / 24, 1 / 6, + 1 / 2)) + u = fma(r * r, p, r) + 1.0 + # 2^q as two factors, so that q from -1443 to 1443 neither wraps nor loses range. + half = q >> 1 + u * pow2(half) * pow2(q - half) +end +vexp(x) = exp(x) + +"""`log(x)` for a positive normal binary64 (NaN to NaN), branch-free.""" +@inline function vlog(x::Float64) + bits = reinterpret(Int64, x) + # x = m 2^e with m in [sqrt(1/2), sqrt(2)): shift the mantissa's top half down. + adjusted = bits + (ONE_BITS - SQRT_HALF_BITS) + e = (adjusted >> 52) - 1023 + m = reinterpret(Float64, (adjusted & MANTISSA) + SQRT_HALF_BITS) + f = m - 1.0 + s = f / (2.0 + f) + z = s * s + # log(1 + f) = 2 atanh(s) = 2s + s R(z), R(z) = sum_k 2 z^k / (2k + 1), to z^11. + R = z * horner(z, 2 / 23, (2 / 21, 2 / 19, 2 / 17, 2 / 15, 2 / 13, 2 / 11, 2 / 9, + 2 / 7, 2 / 5, 2 / 3)) + half = 0.5 * f * f + k = reinterpret(Float64, e + reinterpret(Int64, SHIFT)) - SHIFT + value = fma(k, LN2_HI, f - (half - fma(s, half + R, k * LN2_LO))) + ifelse(x == x, value, x) +end +vlog(x) = log(x) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 649e88eb6..7793bf668 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -319,3 +319,33 @@ def test_julia_stage_scalars_are_the_bundles_bit_for_bit(runtime): held = np.asarray(getattr(path, name))[:, :count] np.testing.assert_array_equal(held, value, err_msg=name) engine.close() + + +def test_julia_vector_maths_is_within_an_ulp_or_two(runtime): + """vexp and vlog (julia/src/vmath.jl) against the C library's functions. + + Each is within one ulp of the correctly rounded value (measured against + BigFloat when written); the C library's within one more, so two bound the gap. + """ + from juliacall import Main # noqa: PLC0415 + + apply = Main.seval("(f, x) -> f.(x)") + generator = np.random.default_rng(11) + x = np.concatenate( + [-745 + 1454 * generator.random(100_000), generator.standard_normal(10_000)] + ) + ours = np.asarray(apply(runtime.vexp, x)) + np.testing.assert_array_less( + np.abs(ours - np.exp(x)), 2 * np.spacing(np.exp(x)) + 1e-320 + ) + x = np.exp(-700 + 1400 * generator.random(100_000)) + ours = np.asarray(apply(runtime.vlog, x)) + np.testing.assert_array_less( + np.abs(ours - np.log(x)), 2 * np.abs(np.spacing(np.log(x))) + ) + specials = np.asarray( + apply(runtime.vexp, np.array([np.nan, np.inf, -np.inf, 800.0])) + ) + assert np.isnan(specials[0]) + assert specials[1:].tolist() == [np.inf, 0.0, np.inf] + assert np.isnan(float(apply(runtime.vlog, np.array([np.nan]))[0])) From c28761386b55b13433a3605f688e6805268bb915 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 23:09:50 +0000 Subject: [PATCH 030/107] Julia: STATUS and README for the engine-side tables, statistics and plasma [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/README.md | 6 ++++-- julia/STATUS.md | 47 ++++++++++++++++++++++++++++++++--------------- 2 files changed, 36 insertions(+), 17 deletions(-) diff --git a/julia/README.md b/julia/README.md index 842ebeb93..83950f83a 100644 --- a/julia/README.md +++ b/julia/README.md @@ -15,11 +15,13 @@ controller and the output are solprop's own. The engine is the Julia package in |---|---| | `SolpropJulia.jl` | the engine type, construction and its warm-up, the bridge's entry points | | `launch.jl` | the device layer: every pass a scalar body run by `each!`, `each_column!`, `reduce_each` or `rowsum!`; FFT plans and GEMMs | +| `vmath.jl` | branch-free binary64 `exp` and `log` within one ulp, for the CPU's vectorised passes | | `modal.jl`, `free.jl` | the modal and radial routes, and Cartesian and line free space | | `responses.jl` | Kerr, one field-plasma channel and one Raman term | | `dopri.jl`, `rk4.jl`, `adams.jl` | the DOPRI5 trial and commit, SEP 24's RK4IP and SEP 16's exponential Adams | -| `stages.jl` | the longitudinal expansions' stage weights | -| `observe.jl` | what the driver reads between steps: the state, the boundary monitor's and the transverse edge's sums | +| `helpers.jl` | the shared code's Chebyshev rows and Adams basis (SEP 29 section 6.6), and an Adams trial's tables | +| `stages.jl` | the longitudinal expansions' stage weights, and the stage scalars from the engine's own tables | +| `observe.jl` | what the driver reads between steps: the state, the boundary monitor's and the transverse edge's sums, the Poynting statistics' power | | `../ext/SolpropJuliaCUDAExt.jl` | CUDA: the engine's arrays become `CuArray`s | ## Setting up diff --git a/julia/STATUS.md b/julia/STATUS.md index 993c86942..0f1455552 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -38,10 +38,16 @@ Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless | Monitor and edge sums, state copies, in the engine | a Cartesian window's host copies and reductions 1.7 s -> 1.1 s | | GPU: plasma and observation populations a sample a thread, scans column-wise | A40 rdw plasma 1.23 s -> 0.04 s, argon 4.9 s -> 0.14 s | | Native's phi-function evaluation (quarter-ulp stop, reciprocals) | radial Adams predictor 0.16 s -> 0.10 s | +| Frequency-domain synthesis where the nodes match the modes (radial) | a radial window 0.86 s -> 0.63 s on 16 threads | +| Its own helpers record (SEP 29 section 6.6), an Adams trial's tables formed in the engine | `rdw` on 16 threads 0.273 s -> 0.214 s; equal to the Python forms bit for bit | +| Stage scalars read by the engine from its own tables (SEP 39's staged tables) | `rdw` stage preparation 17 ms -> 5 ms a window | +| The Poynting statistics' transforms and the populations in the engine, without allocating | `rdw` statistics 55 ms -> 40 ms; collector pauses (13 to 83 ms) gone | +| A plasma column's live samples gathered; vectorised `exp` and `log` (`src/vmath.jl`, 1 ulp) | argon's plasma on one thread 4.7 ms -> 2.9 ms a source | -What did not pay: branch-free vectorised `exp` and `log` (1 ulp, and 2x faster than -Base's in isolation) made the plasma's columns slower in place, where the table gather -keeps the loops scalar and Base's cached exponential is cheaper. +The vectorised functions paid only once the live samples were gathered and each pass +was a function of its own: in the column's branchy loop, and inside its closure, LLVM +kept them scalar, and a table lookup in a loop keeps LLVM from vectorising it, so the +rate is a vectorised `log`, the lookup and a vectorised `exp`, three passes. ## Where it stands @@ -76,16 +82,20 @@ The AMD EPYC 7763 and binary32 rows are in the ledger. ## What is left, measured -- **Host work per step.** The Adams march, its stage scalars and coefficient tables run in - Python: about 1.2 ms a step on the Xeon (rdw at 16 threads: 0.09 s of engine work in a - 0.23 s window). Native runs the march compiled (SEP 39). A Julia march is the largest - remaining CPU and GPU item. -- **Host statistics per plane.** The saved planes' statistics are the shared host - functions: about 4.6 ms a plane on rdw (12 planes in the window). Native forms them in - its own code. -- **Serial plasma.** The column scans' rate (scalar `log` and `exp` behind an exact - zero-support test), fraction and two running integrals take 0.8 s of argon's 1.2 s - window on one thread; native's vectorised SLEEF calls do the same in less. +- **The march in Python.** The Adams controller's decisions and the bridge's calls + between them: about 0.37 ms a step on the Xeon (`argon_blueshift` on 16 threads: + 0.08 s of a 0.40 s window, 213 steps; native's whole step is 0.86 ms). A Julia march + (native's SEP 39, with its decision-trace tests as the oracle) would remove it; the + tables and stage scalars it needs are in the engine already. +- **Host statistics per plane.** The spectra and the reductions over the engine's power + are the shared host functions: about 1.4 ms a plane on `rdw`. +- **The quadrature alarm.** Three forward transforms of the coarse quadrature per + accepted step, each over the modes alone (four columns for `rdw`, so four of 16 + threads): 11 ms of `rdw`'s 0.19 s window. One batched transform of every forward + buffer would fill the pool. +- **Small states on many threads.** With one mode and 1601 bins the passes are serial + by size, and run 20 to 40 % slower with 16 cores busy than with one (the clock). +- **Serial plasma integrals.** The two running integrals are sequential by design. - **Binary32 on x86.** It runs (fields 1e-6 from binary64), but slower than binary64: the scaled field's tails are subnormal, and flush-to-zero is not allowed. GPUs handle binary32 subnormals at full speed. @@ -103,6 +113,13 @@ planes are refused by name. - `parallel_rows` read the CPU topology from sysfs (a file per CPU) before deciding a pass was too small to thread: 60 ms of a 0.36 s rdw window. Fixed on this branch. -- `benchmarks.worker.timed_run` evaluates `simulation.metadata()` inside the timed +- `benchmarks.worker.timed_run` evaluated `simulation.metadata()` inside the timed window, and its first evaluation costs about 0.18 s on rdw (the plane bases' modal - identity): the first timed repeat of every arm, native's included, pays it. + identity): every arm's first timed repeat, native's included, paid it. Fixed on this + branch; ratios measured before it understate both arms' speed (native's `rdw` window + on 16 threads is 0.145 s, not 0.314 s). +- Julia's LinearAlgebra gave wrong products for concurrent `mul!` calls on views of a + `Complex{Float32}` matrix times a `Float32` one (relative error 1.5); the engine forms + them as real GEMMs over the complex array's real view instead. +- `docs/dev/backends.md` still names `set_held_plane` and `held_observation`, which + main removed. From 7c7ac9b7c19f70537c8636fe0ff349da3f62be98 Mon Sep 17 00:00:00 2001 From: John Travers Date: Fri, 6 Nov 2026 23:17:00 +0000 Subject: [PATCH 031/107] Julia: a source's forward transforms, and the alarm's, as one pool's work [skip ci] The state's and the plasma currents' transforms share one blocked plan; each alone spread over the modes only (four columns of rdw, four of 16 threads). transform_all! runs every block of each as the pool's tasks. rdw on 16 threads: commits 12.3 ms -> 5.8 ms, the source's transforms 8.7 ms -> 3.8 ms. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/STATUS.md | 5 +---- julia/src/dopri.jl | 10 ++++++++-- julia/src/launch.jl | 15 +++++++++++++++ julia/src/modal.jl | 11 +++++++++-- julia/src/responses.jl | 4 ++++ 5 files changed, 37 insertions(+), 8 deletions(-) diff --git a/julia/STATUS.md b/julia/STATUS.md index 0f1455552..54d1bb4db 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -43,6 +43,7 @@ Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless | Stage scalars read by the engine from its own tables (SEP 39's staged tables) | `rdw` stage preparation 17 ms -> 5 ms a window | | The Poynting statistics' transforms and the populations in the engine, without allocating | `rdw` statistics 55 ms -> 40 ms; collector pauses (13 to 83 ms) gone | | A plasma column's live samples gathered; vectorised `exp` and `log` (`src/vmath.jl`, 1 ulp) | argon's plasma on one thread 4.7 ms -> 2.9 ms a source | +| A source's forward transforms, and the quadrature alarm's, as one pool's work | `rdw` on 16 threads: commits 12.3 ms -> 5.8 ms, the source's transforms 8.7 ms -> 3.8 ms | The vectorised functions paid only once the live samples were gathered and each pass was a function of its own: in the column's branchy loop, and inside its closure, LLVM @@ -89,10 +90,6 @@ The AMD EPYC 7763 and binary32 rows are in the ledger. tables and stage scalars it needs are in the engine already. - **Host statistics per plane.** The spectra and the reductions over the engine's power are the shared host functions: about 1.4 ms a plane on `rdw`. -- **The quadrature alarm.** Three forward transforms of the coarse quadrature per - accepted step, each over the modes alone (four columns for `rdw`, so four of 16 - threads): 11 ms of `rdw`'s 0.19 s window. One batched transform of every forward - buffer would fill the pool. - **Small states on many threads.** With one mode and 1601 bins the passes are serial by size, and run 20 to 40 % slower with 16 cores busy than with one (the clock). - **Serial plasma integrals.** The two running integrals are sequential by design. diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index a75e23290..8696fa6d5 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -161,8 +161,14 @@ end function quadrature_alarm(engine) c, w = engine.config, engine.work c.spectral && return band_alarm(engine) - mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) - w.plasma === nothing || add_plasma!(w.coarse_spec, w.plasma, w.forward_plan, c; coarse=true) + if w.plasma === nothing + mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) + else + p = w.plasma + transform_all!(w.forward_plan, (w.coarse_spec, p.spectrum, p.edge_spectrum), + (w.projected_coarse, p.coarse, p.coarse_edge)) + add_plasma_spectra!(w.coarse_spec, p, c) + end (; prefactor, omega_window, crop) = c fine, coarse = w.fine, w.coarse_spec T = real_type(engine) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index b5d64fb26..f880da182 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -209,6 +209,21 @@ function LinearAlgebra.mul!(y, p::Blocked, x) end y end +"""`mul!(outs[k], p, ins[k])` for each pair: on a CPU one pool task for each block of +each, so that transforms over a few columns (a capillary's modes) fill the pool.""" +function transform_all!(p::Blocked, outs::Tuple, ins::Tuple) + blocks = length(p.plans) + @batch for k in 1:blocks*length(outs) + j, b = divrem(k - 1, blocks) .+ 1 + transform_block!(p, outs, ins, j, b) + end +end +@inline function transform_block!(p, outs, ins, j, b) + # A tuple's elements by a run-time index: each pair's arrays share one type here. + r = p.ranges[b] + mul!(block_view(outs[j], p.batch, r), p.plans[b], block_view(ins[j], p.batch, r)) +end +transform_all!(p, outs::Tuple, ins::Tuple) = (foreach((y, x) -> mul!(y, p, x), outs, ins); nothing) function Base.:*(p::Blocked, x) @batch for b in eachindex(p.plans) p.plans[b] * block_view(x, p.batch, p.ranges[b]) diff --git a/julia/src/modal.jl b/julia/src/modal.jl index eaf5e7a78..e33dc9988 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -136,8 +136,15 @@ function source!(engine, lab; quadrature=false) gemm!(w.projected_coarse, nodes, @view(c.projection_coarse[first:last, :]), true, true, c) end end - @section :forward_fft mul!(w.fine, w.forward_plan, w.projected) - w.plasma === nothing || @section :plasma_spectrum add_plasma!(w.fine, w.plasma, w.forward_plan, c) + if w.plasma === nothing + @section :forward_fft mul!(w.fine, w.forward_plan, w.projected) + else + # The source's and the currents' transforms as one pool's work. + p = w.plasma + @section :forward_fft transform_all!(w.forward_plan, (w.fine, p.spectrum, p.edge_spectrum), + (w.projected, p.projected, p.edge_projected)) + @section :plasma_spectrum add_plasma_spectra!(w.fine, p, c) + end if c.in_stage absorber!(w.absorber, w.modal, c) isempty(c.spatial_absorber) || gemm!(w.absorber, w.modal, c.spatial_absorber, true, true, c) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 39d9042e4..64813adb4 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -371,6 +371,10 @@ end function add_plasma!(destination, p, plan, c; coarse=false, direct=false) mul!(p.spectrum, plan, direct ? p.gated : coarse ? p.coarse : p.projected) mul!(p.edge_spectrum, plan, direct ? p.edge : coarse ? p.coarse_edge : p.edge_projected) + add_plasma_spectra!(destination, p, c) +end +"""Add `-i J / omega + edge / omega^2` of the currents' spectra, already transformed.""" +function add_plasma_spectra!(destination, p, c) (; spectrum, edge_spectrum, inverse_omega) = p crop, mask = c.crop, c.mask each!(c, length(crop), size(destination, 2)) do f, m From 207add18e7d0f4b4fe545d3f0f605eb36a5a7486 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 00:04:33 +0000 Subject: [PATCH 032/107] Julia: the exponential Adams march executed by the engine [skip ci] julia/src/march.jl transcribes AdamsMarch's decisions and loop, by way of native's adams_march.cpp (SEP 39 phase 2), and runs a run of attempts on the resident engine, returning to Python only at a host event; the call protocol, the bounds and the adoption follow native's _NativeAdamsMarch (src/solprop/backends/julia/_march.py). The same attempts, ledger, orders and field bit for bit as the Python march (tested on rdw, argon and ctc). A replayed schedule, a split collar, interpolated planes, the carrier frame and SOLPROP_JULIA_MARCH=host keep the Python march. argon_blueshift on 16 Xeon threads 0.42 s -> 0.34 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 9 + julia/src/free.jl | 2 +- julia/src/march.jl | 425 +++++++++++++++++++++++++ julia/src/modal.jl | 2 +- src/solprop/backends/julia/_backend.py | 34 +- src/solprop/backends/julia/_march.py | 366 +++++++++++++++++++++ tests/backends/test_julia.py | 51 +++ 7 files changed, 885 insertions(+), 4 deletions(-) create mode 100644 julia/src/march.jl create mode 100644 src/solprop/backends/julia/_march.py diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 07a96696a..8302f00ab 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -43,6 +43,7 @@ include("dopri.jl") include("rk4.jl") include("adams.jl") include("helpers.jl") +include("march.jl") include("stages.jl") include("observe.jl") @@ -117,6 +118,13 @@ function warm!(engine) column_energy(engine) w.edge[] = nothing w.plasma === nothing || population_snapshot(engine, nothing) + reset_work!(engine) +end + +"""Zero the state and every buffer a warm-up wrote, and the engine's counters.""" +function reset_work!(engine) + c, w = engine.config, engine.work + a = w.adams buffers = (w.y, w.candidate, w.lab, w.source, w.error, w.stages, w.forward, w.inverse) a === nothing || (buffers = (buffers..., a.store, a.states, a.rates, a.moments, a.carried, a.endpoint)) foreach(buffer -> fill!(buffer, 0), buffers) @@ -204,5 +212,6 @@ const bind_edge_b = bind_edge! const trial_b = trial! const commit_b = commit! const evaluate_b = evaluate! +const reset_work_b = reset_work! end diff --git a/julia/src/free.jl b/julia/src/free.jl index 21f49465a..3e6150254 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -46,7 +46,7 @@ function create_free(c, host) coarse, coarse_spec = dzeros(c, R, nc, chunk), dzeros(c, C, nw, chunk) planes = (threads=c.transverse_fft_threads, batch=1) work = ( - adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), + adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), plasma=plasma_workspace(c, host, nt, chunk, chunk, nm), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), diff --git a/julia/src/march.jl b/julia/src/march.jl new file mode 100644 index 000000000..f75fcfea8 --- /dev/null +++ b/julia/src/march.jl @@ -0,0 +1,425 @@ +# The exponential Adams march, executed by the engine (native's SEP 39 phase 2 march). +# +# solprop's `AdamsMarch` and its controller core (`solprop.backends.adams_core`) are +# the reference, and native's `adams_march.cpp` the transcription this follows: the +# march runs a run of attempts on the resident engine and returns to Python only at a +# host event (the target reached, an accepted step with the driver's work, a monitor +# check, the call's bound, the budget, the floor or an error). Each decision performs +# its Python function's operations in order, with Python's comparisons: `min(a, b)` is +# `b` only if `b < a`, `max` keeps the first unless a later is strictly greater, a +# comparison with NaN is false. Julia contracts nothing unasked, and `pow` is the C +# library's, as Python's float power is. + +const LIBM = Sys.isapple() ? "libSystem.B.dylib" : "libm.so.6" +"""Python's `x ** y` for floats: the C library's `pow`.""" +cpow(x::Float64, y::Float64) = ccall((:pow, LIBM), Float64, (Float64, Float64), x, y) +py_min(a, b) = b < a ? b : a +py_max(a, b) = b > a ? b : a +"""`math.ulp` at a magnitude: the spacing above `|x|`; NaN for a non-finite one.""" +function ulp(x::Float64) + m = abs(x) + isfinite(m) ? nextfloat(m) - m : NaN +end +"""`bisect.bisect_left` and `bisect_right`: how many entries lie below (at or below).""" +bisect_left(values, x) = searchsortedfirst(values, x) - 1 +bisect_right(values, x) = searchsortedlast(values, x) + +"""Every number the algorithm reads: solprop's `MarchPolicy`, field for field.""" +struct Policy + order::Int + variable_order::Bool + safety::Float64 + max_growth::Float64 + min_factor::Float64 + rejection_growth::Float64 + hysteresis::Float64 + restart_after::Int + collar_stability::Float64 + real_intervals::Vector{Float64} + collar_rate::Float64 + has_budget::Bool + max_calls::Int + equal_approach::Bool + dz_min::Float64 + dz_max::Float64 + stretch::Float64 + z_end::Float64 + save_planes::Vector{Float64} + hard_kinks::Vector{Float64} + breakpoints::Vector{Float64} + landing_ulps::Int + has_quiet_interval::Bool + quiet_interval::Float64 +end + +"""A march's configuration: its policy, the stage count the stage scalars fill, and +the operator's rate table for a compensated trial (`translate.linop.rate_weights`).""" +struct MarchConfig{R} + policy::Policy + stages::Int + varying::Bool + compensated::Bool + rate::R +end + +const NONE, MAX_STEP, INTERVAL_WIDTH, HARD_KINK, SAVE_PLANE, END = 0, 1, 2, 3, 4, 5 +const REACHED, HOST_STEP, MONITOR, BOUND, BUDGET, FLOOR, ERROR, DIVERGED = 0:7 +const STAGE_NONE, STARTUP, TRIAL, ACCEPT = 0:3 +const CONVERGENCE, BACKEND, VALUE = 1:3 + +# --- the decisions (adams_core) -------------------------------------------------------- + +function factor(p::Policy, norm, order, growth) + norm <= 0.0 && return growth + raw = p.safety * cpow(norm, -1.0 / Float64(order + 1)) + py_min(growth, py_max(p.min_factor, raw)) +end + +"""A trial's history newest first: its nodes and rows, its order and scored orders.""" +function stencil(p::Policy, z, dz, history_z, history_row, stored_order, last_rejected) + held = length(history_z) + nodes = [(history_z[held-i] - z) / dz for i in 0:held-1] + rows = [history_row[held-i] for i in 0:held-1] + order = min(stored_order, held) + rising = !last_rejected && held > order + orders = [order] + if p.variable_order + order >= 2 && order - 1 <= p.order && order - 1 <= held && push!(orders, order - 1) + order + 1 <= p.order && order + 1 <= held && rising && push!(orders, order + 1) + end + (nodes=nodes, rows=rows, held=held, order=order, orders=orders) +end + +function stable_factor(p::Policy, order, dz, quiet) + (p.collar_rate <= 0.0 || quiet) && return Inf + p.collar_stability * p.real_intervals[order] / (p.collar_rate * dz) +end + +function order_weight(p::Policy, norm, order, dz, quiet) + rate = norm <= 0.0 ? Inf : cpow(norm, -1.0 / Float64(order + 1)) + py_min(p.safety * rate, stable_factor(p, order, dz, quiet)) +end + +"""The order to store, and the order and norm that set the next step.""" +function choose_order(p::Policy, s, norms, dz, quiet) + current = s.order + p.variable_order || return (p.order, current, norms[1]) + weights = [order_weight(p, norms[i], s.orders[i], dz, quiet) for i in eachindex(s.orders)] + best = 1 + for i in 2:length(weights) + weights[i] > weights[best] && (best = i) + end + if s.orders[best] != current && weights[best] > p.hysteresis * weights[1] + return (s.orders[best], s.orders[best], norms[best]) + end + (current, current, norms[1]) +end + +function rejection(p::Policy, norm, order, rejections, held) + count = rejections + 1 + restart = count >= p.restart_after && held > 1 + scale = !isfinite(norm) ? p.min_factor : factor(p, norm, order, p.rejection_growth) + (scale, restart ? 0 : count, restart) +end + +quiet_capped(p::Policy, proposal, quiet) = + (!quiet || !p.has_quiet_interval) ? proposal : py_min(proposal, p.quiet_interval) + +function collar_reentry(p::Policy, proposal, order, was_quiet, quiet) + (!(was_quiet && !quiet) || p.collar_rate <= 0.0) && return proposal + py_min(proposal, p.collar_stability * p.real_intervals[order] / p.collar_rate) +end + +"""`stepper.schedule.landing`: the step a landing allows, its target and end.""" +function landing(p::Policy, z, dz, z_end) + (dz > 0.0 && isfinite(dz)) || throw(ArgumentError("dz must be finite and positive, got $dz")) + edges = p.breakpoints + edges[1] <= z <= edges[end] || throw(ArgumentError("z = $z m lies outside the operator table")) + tolerance = p.landing_ulps * ulp(py_max(abs(z), abs(z_end))) + z >= z_end - tolerance && throw(ArgumentError("z = $z m is already at or past z_end")) + found = bisect_right(edges, z) + index = min(found == 0 ? 0 : found - 1, length(edges) - 2) + width = edges[index+2] - edges[index+1] + # The caps, then the landings: the shortest wins, among equals the higher target. + better(c, h) = c[1] < h[1] ? true : h[1] < c[1] ? false : c[2] > h[2] + cap = (dz, NONE, 0.0) + for other in ((p.dz_max, MAX_STEP, 0.0), (width, INTERVAL_WIDTH, 0.0)) + better(other, cap) && (cap = other) + end + land, any = (0.0, NONE, 0.0), false + consider(target, position) = (candidate = (position - z, target, position); + if !any || better(candidate, land); land = candidate; any = true; end) + from = z + tolerance + k = bisect_left(p.hard_kinks, from) + k < length(p.hard_kinks) && consider(HARD_KINK, p.hard_kinks[k+1]) + q = bisect_left(p.save_planes, from) + q < length(p.save_planes) && consider(SAVE_PLANE, p.save_planes[q+1]) + !(z_end < from) && consider(END, z_end) + land[1] <= cap[1] && return (dz=land[1], target=land[2], landed=true, at=land[3]) + land[1] <= py_min(p.stretch * cap[1], p.dz_max) && + return (dz=land[1], target=land[2], landed=true, at=land[3]) + (dz=cap[1], target=cap[2], landed=false, at=0.0) +end + +"""The next forced landing strictly beyond `z` (`adams_core.next_landing`), or nothing.""" +function next_landing(p::Policy, z, target) + tolerance = p.landing_ulps * ulp(py_max(abs(z), abs(target))) + nearest = target + for positions in (p.save_planes, p.hard_kinks) + index = bisect_right(positions, z + tolerance) + index < length(positions) && (nearest = py_min(nearest, positions[index+1])) + end + nearest > z + tolerance ? nearest : nothing +end + +"""The step to take, where it ends and whether that is a hard kink.""" +function approach(p::Policy, z, stop, target) + if !stop.landed && p.equal_approach + ahead = next_landing(p, z, target) + if ahead !== nothing && stop.dz < ahead - z && ahead - z < 2.0 * stop.dz + half = 0.5 * (ahead - z) + return (dz=half, finish=z + half, kink=false) + end + end + finish = stop.landed ? stop.at : z + stop.dz + tolerance = p.landing_ulps * ulp(py_max(abs(finish), 1.0)) + interior = finish < p.z_end - tolerance + on_kink = interior && any(kink -> abs(kink - finish) <= tolerance, p.hard_kinks) + (dz=stop.dz, finish=finish, kink=stop.target == HARD_KINK || on_kink) +end + +proposal(p::Policy, dz, f) = py_min(dz * f, p.dz_max) +reached(position, target, ulps) = + position >= target - ulps * ulp(py_max(abs(position), abs(target))) + +# --- the engine's part ----------------------------------------------------------------- + +"""`translate.linop.rate_weights`: the operator's rate terms at `z`, read on the side +of a breakpoint `before` asks, by the transcribed Clenshaw pass on that interval.""" +function rate_at(table, z, before) + edges = table.edges + low, high = edges[1], edges[end] + slack = 1e-10 * (high - low) + (z < low - slack || z > high + slack) && + throw(ArgumentError("z = $z is outside the represented span [$low, $high]")) + index = min(max(searchsortedlast(edges, z) - 1, 0), length(edges) - 2) + before && index > 0 && z <= edges[index+1] && (index -= 1) + out = zeros(1, size(table.c, 3)) + clenshaw_points!([Float64(z)], [edges[index+1], edges[index+2]], -Inf, Inf, + view(table.c, index+1:index+1, :, :), out) + vec(out) +end + +"""The stage scalars of a trial from `z` over `dz` (the adapter's `_prepare_stages`).""" +stage_positions(m::MarchConfig, z, dz) = [fill(Float64(z), m.stages - 1); z + dz] + +function march_start!(engine, m::MarchConfig, z) + m.varying && configure_stages_at!(engine, z, stage_positions(m, z, 0.0)) + m.compensated && configure_adams_rate!(engine, rate_at(m.rate, z, false)) + adams_start!(engine) +end + +function march_trial!(engine, m::MarchConfig, z, dz, s) + m.varying && configure_stages_at!(engine, z, stage_positions(m, z, dz)) + rate = m.compensated ? rate_at(m.rate, z + dz, true) : Float64[] + configure_adams_nodes!(engine, s.nodes, s.order, s.orders, s.rows, rate) + adams_trial!(engine, dz) +end + +"""Adopt the held trial into row `free`, commit it; return its quadrature alarm.""" +function march_accept!(engine, dz, free) + adams_accept!(engine, free) + commit!(engine, Float64(dz), false) +end + +# --- the run --------------------------------------------------------------------------- + +"""Hold a run's march configuration: the policy's numbers as `MarchPolicy` gives them.""" +function configure_march!(engine, numbers, real_intervals, save_planes, hard_kinks, + breakpoints, stages, varying, compensated, rate_edges, rate_c) + f = Vector{Float64}(numbers) + policy = Policy(Int(f[1]), f[2] != 0, f[3], f[4], f[5], f[6], f[7], Int(f[8]), f[9], + Vector{Float64}(real_intervals), f[10], f[11] != 0, Int(f[12]), + f[13] != 0, f[14], f[15], f[16], f[17], Vector{Float64}(save_planes), + Vector{Float64}(hard_kinks), Vector{Float64}(breakpoints), Int(f[18]), + f[19] != 0, f[20]) + rate = compensated ? (edges=Vector{Float64}(rate_edges), c=Array{Float64,3}(rate_c)) : + nothing + engine.work.march[] = MarchConfig(policy, Int(stages), Bool(varying), Bool(compensated), + rate) + nothing +end + +"""One call of the march: from the state Python holds to a host event (SEP 39 4.8). + +`zs` = (z, proposal); `counts` = (order, rejections, last_rejected, collar_was_quiet); +the history oldest first; `ledger` (startup, predictor, rejected, accepted_steps, +rejected_steps, restarts, failure_restarts), `CallLedger`'s counters; `limits` = (target, check_interval, +last_check, read_at, read_spacing, step_cap, max_seconds) and `flags` = (quiet, +host_step, monitor, first_check, has_read_at, max_attempts). Returns the state, the +attempts' rows (end, dz, norm, accepted, order, wall), the accepted orders, the reason +and its details, the last accepted step's quadrature alarm, and the first above 1e-6 +with where it was. +""" +march_run!(engine, zs, counts, history_z, history_predicted, history_row, ledger, limits, + flags) = + run_march(engine, engine.work.march[], Vector{Float64}(zs), Vector{Int}(counts), + Vector{Float64}(history_z), Vector{Bool}(history_predicted), + Vector{Int}(history_row), Vector{Int}(ledger), Vector{Float64}(limits), + Vector{Int}(flags)) + +function run_march(engine, m::MarchConfig, zs, counts, hz, hp, hr, ledger, limits, flags) + p = m.policy + started = time() + z, proposed = zs + order, rejections = counts[1], counts[2] + last_rejected, was_quiet = counts[3] != 0, counts[4] != 0 + target, check_interval, last_check, read_at, read_spacing, step_cap, max_seconds = limits + quiet, monitor, first_check, has_read_at = flags[1] != 0, flags[3] != 0, flags[4] != 0, + flags[5] != 0 + host_step, max_attempts = flags[2], flags[6] + rows, orders = Float64[], Int[] + reason, cost, floor_proposal, stage, category, message = REACHED, 0, 0.0, STAGE_NONE, 0, "" + alarm, alarm_z, first_alarm = NaN, NaN, NaN + accepted = 0 + elapsed() = time() - started + record(finish, dz, norm, kept, o) = + append!(rows, (finish, dz, isfinite(norm) ? norm : Inf, kept ? 1.0 : 0.0, Float64(o), + elapsed())) + total() = ledger[1] + ledger[2] + function fail(at, error) + reason, stage = ERROR, at + message = sprint(showerror, error) + category = error isa ArgumentError ? VALUE : BACKEND + end + read_due(z, ahead) = has_read_at && z + ahead >= read_at - 1e-12 * py_max(abs(z), 1.0) + while !reached(z, target, p.landing_ulps) + # The budget, before any call is made (`_afford`). + need = (isempty(hz) ? 1 : 0) + 1 + if p.has_budget && total() + need > p.max_calls + reason, cost = BUDGET, need + @goto done + end + if isempty(hz) + ledger[1] += 1 + failed = false + try + march_start!(engine, m, z) + catch error + fail(STARTUP, error) + failed = true + end + failed && @goto done + hz, hp, hr = [z], [false], [0] + order = p.variable_order ? 1 : p.order + end + # The caps: the quiet collar's, the transverse edge's, the split's, re-entry's. + capped = quiet_capped(p, proposed, quiet) + capped = has_read_at ? py_min(capped, read_spacing) : capped + capped = py_min(capped, step_cap) + capped = collar_reentry(p, capped, order, was_quiet, quiet) + was_quiet = quiet + step = nothing + try + step = approach(p, z, landing(p, z, capped, target), target) + catch error + fail(TRIAL, error) + end + step === nothing && @goto done + s = stencil(p, z, step.dz, hz, hr, order, last_rejected) + ledger[2] += 1 + norms = nothing + try + norms = march_trial!(engine, m, z, step.dz, s) + catch error + fail(TRIAL, error) + end + norms === nothing && @goto done + norm = norms[1] + if !(norm <= 1.0) + # A rejection keeps the accepted history; `restart_after` in a row restart it. + ledger[3] += 1 + ledger[5] += 1 + last_rejected = true + scale, rejections, restart = rejection(p, norm, s.order, rejections, length(hz)) + if restart + hz, hp, hr = Float64[], Bool[], Int[] + ledger[7] += 1 + end + next = proposal(p, step.dz, scale) + if next < p.dz_min + reason, floor_proposal = FLOOR, next + @goto done + end + proposed = next + record(step.finish, step.dz, norm, false, s.order) + else + # The new sample takes the lowest row the kept entries do not use. + keep = min(p.order, length(hz)) + kz, kp, kr = hz[end-keep+1:end], hp[end-keep+1:end], hr[end-keep+1:end] + free = 0 + while free in kr + free += 1 + end + failed = false + try + alarm = march_accept!(engine, step.dz, free) + catch error + fail(ACCEPT, error) + failed = true + end + failed && @goto done + # The first step past the alarm's level, for the adapter's one warning. + if alarm > 1e-6 && isnan(alarm_z) + alarm_z = z + step.dz + first_alarm = alarm + end + hz, hp, hr = [kz; z + step.dz], [kp; true], [kr; free] + ledger[4] += 1 + rejections = 0 + push!(orders, s.order) + stored, control, control_norm = choose_order(p, s, norms, step.dz, quiet) + order = stored + last_rejected = false + z = step.finish + if step.kink + hz, hp, hr = Float64[], Bool[], Int[] + ledger[6] += 1 + end + next = proposal(p, step.dz, factor(p, control_norm, control, p.max_growth)) + record(step.finish, step.dz, norm, true, s.order) + if next < p.dz_min + reason, floor_proposal = FLOOR, next + @goto done + end + proposed = next + accepted += 1 + if reached(z, target, p.landing_ulps) + reason = REACHED + @goto done + end + if (host_step > 0 && accepted == host_step) || read_due(z, proposed) + reason = HOST_STEP + @goto done + end + if monitor && (first_check || z - last_check >= check_interval) + reason = MONITOR + @goto done + end + end + if length(rows) ÷ 6 >= max_attempts || elapsed() >= max_seconds + reason = BOUND + @goto done + end + end + reason = REACHED + @label done + (zs=[z, proposed], counts=[order, rejections, Int(last_rejected), Int(was_quiet)], + history_z=hz, history_predicted=hp, history_row=hr, ledger=ledger, rows=rows, + orders=orders, reason=reason, cost=cost, floor_proposal=floor_proposal, stage=stage, + category=category, message=message, alarm=alarm, alarm_z=alarm_z, + first_alarm=first_alarm) +end + +const configure_march_b = configure_march! +const march_run_b = march_run! diff --git a/julia/src/modal.jl b/julia/src/modal.jl index e33dc9988..57f61d226 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -76,7 +76,7 @@ function create_modal(c, host) node_forward=spectral ? plan(c, plan_rfft, nodes, 1) : nothing, absorber_spec_band=dzeros(c, C, spectral && in_stage ? nw : 0, spectral && in_stage ? nm : 0), adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), - monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), statistics=Ref{Any}(nothing), + monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), statistics=Ref{Any}(nothing), raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 198d02931..cb9cc9392 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -17,6 +17,7 @@ from solprop.backends.driver import StepDriver, refuse_general_leaves from solprop.backends.exponential import refuse_carrier_frame from solprop.backends.julia._helpers import JULIA +from solprop.backends.julia._march import JuliaAdamsMarch from solprop.backends.julia._runtime import ( call_julia, runtime, @@ -53,6 +54,7 @@ __all__ = ["JuliaBackend"] + logger = logging.getLogger(__name__) _SPECIES_STATS = frozenset( ( @@ -484,9 +486,37 @@ def __init__( self._low_storage = LowStorageMarch(self, problem.stepper.integrator) if isinstance(problem.stepper.integrator, Multistep): - from solprop.backends.multistep import AdamsMarch # noqa: PLC0415 + self._adams = JuliaAdamsMarch(self, problem.stepper.integrator) + if self._adams.native: + self._warm_march(self._adams) + + def _warm_march(self, march: JuliaAdamsMarch) -> None: + """Run one attempt of Julia's march over a sliver of the span, then reset. + + The engine's buffers are zeroed again: the march compiles here, not in the + first window. - self._adams = AdamsMarch(self, problem.stepper.integrator) + Parameters + ---------- + march : solprop.backends.julia._march.JuliaAdamsMarch + The run's march, which Julia's steps. + """ + march._configure() + z0 = float(self._problem.initial.z) + limits, flags = march._bounds(z0 + 1e-9 * (march._policy.z_end - z0)) + call_julia( + self._jl.march_run_b, + self._engine, + np.array([z0, self._proposal]), + np.array([1, 0, 0, 0], dtype=np.int64), + np.empty(0), + np.zeros(0, dtype=bool), + np.zeros(0, dtype=np.int64), + np.zeros(7, dtype=np.int64), + limits, + flags, + ) + call_julia(self._jl.reset_work_b, self._engine) def _warm_bridge(self) -> None: """Call each bridge entry the march reaches with the arguments it will pass. diff --git a/src/solprop/backends/julia/_march.py b/src/solprop/backends/julia/_march.py new file mode 100644 index 000000000..14e2bf002 --- /dev/null +++ b/src/solprop/backends/julia/_march.py @@ -0,0 +1,366 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +"""The exponential Adams march executed by the Julia engine (SEP 39's native march). + +The algorithm is :class:`~solprop.backends.multistep.AdamsMarch`'s, which stays the +reference: ``julia/src/march.jl`` transcribes it (by way of native's +``adams_march.cpp``) and performs a run of attempts on the resident engine, returning +to Python only at a host event: the target reached, an accepted step on which the +driver has work (a statistics row, a natural stop, a monitor check, a transverse +read), the call's bound, the budget, the floor or an error. Between calls the march's +state is this object's, as the Python march keeps it, so a snapshot, a reset and a +new run are the reference's own. The call protocol, the bounds and the adoption follow +native's ``_NativeAdamsMarch``. + +A configuration the Julia march does not cover runs the Python march +(:attr:`JuliaAdamsMarch.refusal`): a replayed schedule, a split collar, interpolated +planes, the carrier frame, a compensated trial without an expansion's rate table, or +``SOLPROP_JULIA_MARCH=host``. +""" + +import logging +import math +import os +import time +from typing import Any + +import numpy as np + +from solprop._interrupts import committing +from solprop.backends.driver import reached +from solprop.backends.julia._runtime import call_julia +from solprop.backends.multistep import ( + AdamsMarch, + _Derivative, # pyright: ignore[reportPrivateUsage] - the march's history entries +) +from solprop.exceptions import BackendError, ConvergenceError +from solprop.stepper import Multistep + +logger = logging.getLogger(__name__) + +__all__ = ["JuliaAdamsMarch"] + +_REACHED, _HOST_STEP, _MONITOR, _BOUND, _BUDGET, _FLOOR, _ERROR, _DIVERGED = range(8) +_CONVERGENCE, _BACKEND, _VALUE = 1, 2, 3 +_COUNTERS = ( + "startup", + "predictor", + "rejected", + "accepted_steps", + "rejected_steps", + "restarts", + "failure_restarts", +) +"""The call ledger's counters the Julia march keeps, in its order.""" + + +class JuliaAdamsMarch(AdamsMarch): + """solprop's exponential Adams march, executed by the Julia engine. + + Parameters + ---------- + backend : solprop.backends.julia.JuliaBackend + The backend whose engine steps. + method : solprop.stepper.Multistep + The exponential Adams method. + """ + + MAX_ATTEMPTS = 256 + """A call's most attempts, the bound on the wait of a signal or a stop flag.""" + MAX_SECONDS = 0.1 + """A call's most wall time, s, read once per attempt.""" + + def __init__(self, backend: Any, method: Multistep) -> None: + """Build the Python march, then decide which march steps the run.""" + super().__init__(backend, method) + # The driver's protected bookkeeping, which this march books into exactly as + # solprop's does (``DRIVER_SURFACE``), as native's march reaches it. + self._driver: Any = backend + self._configured: tuple[float | None] | None = None + self.refusal = self._refusal() + """Why the Python march steps the run, or ``None`` when Julia's does.""" + + @property + def native(self) -> bool: + """Whether the Julia march steps the run.""" + return self.refusal is None + + def _refusal(self) -> str | None: + """Return why the Julia march does not step the run, or ``None``.""" + from solprop.backends.julia._backend import _splits # noqa: PLC0415 - cycle + + problem = self._driver._problem + engine: Any = self._engine + reasons = ( + (os.environ.get("SOLPROP_JULIA_MARCH") == "host", "asked for"), + (self._exponential is None, "not the exponential formulation"), + (problem.stepper.schedule is not None, "a replayed schedule"), + (_splits(problem), "a split collar"), + (self._interpolate, "interpolated planes"), + (self._policy.carrier, "the carrier frame"), + ( + engine.compensated and problem.linear.phi_expansion is None, + "a compensated trial without an expansion", + ), + ) + return next((reason for failed, reason in reasons if failed), None) + + def march_to(self, target: float) -> None: + """Step the backend's state to `target`, by Julia's march when admitted. + + Parameters + ---------- + target : float + Position to reach, m. + """ + if not self.native: + super().march_to(target) + return + backend = self._driver + if backend._natural_stop_due(target): + return + self._configure() + while not reached(backend._z, target): + if self._call(target): + return + + def _configure(self) -> None: + """Hand the engine the run's policy, again when the monitor's interval moved.""" + monitor = self._driver._monitor + interval = None if monitor is None else float(monitor.interval) + if self._configured == (interval,): + return + policy = self._policy + backend = self._driver + problem = backend._problem + engine: Any = self._engine + numbers = np.array( + [ + policy.order, + policy.variable_order, + policy.safety, + policy.max_growth, + policy.min_factor, + policy.rejection_growth, + policy.hysteresis, + policy.restart_after, + policy.collar_stability, + policy.collar_rate, + policy.max_calls is not None, + 0 if policy.max_calls is None else policy.max_calls, + policy.equal_approach, + policy.dz_min, + policy.dz_max, + policy.stretch, + policy.z_end, + policy.landing_ulps, + interval is not None, + 0.0 if interval is None else interval, + ], + dtype=np.float64, + ) + edges = coefficients = np.empty(0) + if engine.compensated: + edges, _, _, coefficients = problem.linear.rate.packed() + call_julia( + backend._jl.configure_march_b, + backend._engine, + numbers, + np.asarray(policy.real_intervals, dtype=np.float64), + np.asarray(policy.save_planes, dtype=np.float64), + np.asarray(policy.hard_kinks, dtype=np.float64), + np.asarray(policy.breakpoints, dtype=np.float64), + len(problem.stepper.tableau.nodes), + bool(backend._varying), + bool(engine.compensated), + np.ascontiguousarray(edges, dtype=np.float64), + np.ascontiguousarray(coefficients, dtype=np.float64) + if engine.compensated + else np.zeros((0, 0, 0)), + ) + self._configured = (interval,) + + def _bounds(self, target: float) -> tuple[np.ndarray, np.ndarray]: + """Return a call's bounds: the target, and the steps the driver has work on. + + Returns + ------- + tuple of numpy.ndarray + The limits (target, check interval, last check, read position and + spacing, step cap, seconds) and flags (quiet, host step, monitor, first + check, a read due, attempts) of ``march_run!``. + """ + backend = self._driver + steps: list[int] = [] + if backend._row_spec is not None: + period = backend._row_period + steps.append(period - backend._accepted_steps % period) + every = backend._problem.stepper.step_planes + if every: + steps.append(every - backend._natural_count % every) + monitor = backend._monitor + checked = None + read_at = None + spacing = 0.0 + if monitor is not None: + steps.append(monitor.steps_to_check()) + checked = monitor.checked_at + # The transverse edge is read on the host (SEP 40 section 5.3): steps are + # capped at its spacing, and the march returns before one would carry + # past its next read. + edge = monitor.transverse + if edge is not None: + if edge.every_step: + steps.append(1) + if math.isfinite(edge.next_read): + read_at = float(edge.next_read) + spacing = float(edge.ceiling(backend._z)) + limits = np.array( + [ + target, + 0.0 if monitor is None else float(monitor.interval), + 0.0 if checked is None else float(checked), + 0.0 if read_at is None else read_at, + spacing, + math.inf if monitor is None else float(monitor.step_cap), + self.MAX_SECONDS, + ] + ) + flags = np.array( + [ + bool(backend._collar_quiet), + int(min(steps)) if steps else 0, + checked is not None, + False, + read_at is not None, + self.MAX_ATTEMPTS, + ], + dtype=np.int64, + ) + return limits, flags + + def _call(self, target: float) -> bool: + """Make one Julia call and drain it; return whether a natural stop is due.""" + backend = self._driver + backend._poll_stop() + limits, flags = self._bounds(target) + started = time.perf_counter() - backend._clock + history = self._history + with committing(): + result = call_julia( + backend._jl.march_run_b, + backend._engine, + np.array([backend._z, backend._proposal]), + np.array( + [ + self._order, + self._rejections, + self._last_rejected, + self._collar_was_quiet, + ], + dtype=np.int64, + ), + np.array([entry.z for entry in history], dtype=np.float64), + np.array([entry.identity == "predicted" for entry in history]), + np.array([entry.slot for entry in history], dtype=np.int64), + np.array([getattr(self.ledger, name) for name in _COUNTERS]), + limits, + flags, + nogil=True, + ) + self._synchronise(result) + rows = np.asarray(result.rows, dtype=np.float64).reshape(-1, 6) + reason = int(result.reason) + # Only the last accepted row of an event can have the driver's work; the + # others take the skip path, as the reference's would. + event = reason in (_REACHED, _HOST_STEP, _MONITOR) + last = len(rows) - 1 + for index, (end, dz, norm, accepted, _, wall) in enumerate(rows.tolist()): + backend._record_attempt(end, dz, norm, bool(accepted), started + wall) + final = index == last and (event or reason == _FLOOR) + if accepted and not final: + backend._skip_step(end) + progress = backend._progress + for end, dz, norm, accepted, order, _ in rows.tolist(): + progress.step(end, dz, bool(accepted)) + if logger.isEnabledFor(logging.DEBUG): + logger.debug( + "julia Adams attempt to z = %.9g m: dz = %.4g m, order %d, " + "norm %.4g, %s", + end, + dz, + int(order), + norm, + "accepted" if accepted else "rejected", + ) + if event and rows.size and rows[-1, 3]: + backend._take_step_stats() + if backend._natural_stop(target): + return True + self._raise(reason, result) + return False + + def _synchronise(self, result: Any) -> None: + """Adopt the state a Julia call handed back.""" + backend = self._driver + z, proposal = np.asarray(result.zs).tolist() + backend._z, backend._proposal = float(z), float(proposal) + order, rejections, last_rejected, was_quiet = np.asarray(result.counts).tolist() + self._order, self._rejections = int(order), int(rejections) + self._last_rejected, self._collar_was_quiet = ( + bool(last_rejected), + bool(was_quiet), + ) + self._history = [ + _Derivative( + float(z), None, "predicted" if predicted else "accepted", int(row) + ) + for z, predicted, row in zip( + np.asarray(result.history_z).tolist(), + np.asarray(result.history_predicted).tolist(), + np.asarray(result.history_row).tolist(), + strict=True, + ) + ] + ledger = self.ledger + for name, value in zip( + _COUNTERS, np.asarray(result.ledger).tolist(), strict=True + ): + setattr(ledger, name, int(value)) + orders = np.asarray(result.orders).tolist() + ledger.orders.extend(int(order) for order in orders) + if orders: + # The accepted steps' commits, which the engine made: what `_finish` sets. + backend._alarm = float(result.alarm) + backend._state = backend._engine + backend._fsal = backend._recycle + first = float(result.first_alarm) + if not math.isnan(first) and not backend._alarm_reported: + backend._alarm_reported = True + logger.warning( + "transverse quadrature error %.2e exceeds 1e-6 at z=%.6g m; " + "refine the quadrature", + first, + float(result.alarm_z), + ) + + def _raise(self, reason: int, result: Any) -> None: + """Raise the error a call returned with, if any.""" + if reason == _BUDGET: + raise self._budget_error(int(result.cost)) + if reason == _FLOOR: + proposed = float(result.floor_proposal) + msg = ( + f"step control asked for {proposed:.3e} m, below the floor dz_min =" + f" {self._policy.dz_min:.3e} m; the tolerance cannot be met here" + ) + raise ConvergenceError(msg) + if reason == _ERROR: + message = str(result.message) + category = int(result.category) + if category == _CONVERGENCE: + raise ConvergenceError(message) + if category == _VALUE: + raise ValueError(message) + raise BackendError(f"julia execution failed: {message}") diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 7793bf668..855c8a769 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -349,3 +349,54 @@ def test_julia_vector_maths_is_within_an_ulp_or_two(runtime): assert np.isnan(specials[0]) assert specials[1:].tolist() == [np.inf, 0.0, np.inf] assert np.isnan(float(apply(runtime.vlog, np.array([np.nan]))[0])) + + +def _march(configuration, march): + """Run a window with the named march; return the field, history and ledger.""" + os.environ["SOLPROP_JULIA_MARCH"] = march + try: + simulation = build(configuration) + problem = simulation.translate() + engine = select( + "julia", + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + finally: + del os.environ["SOLPROP_JULIA_MARCH"] + assert engine._adams.native == (march == "julia") + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(float(configuration["stop"])) + field = engine.observe(field=True).field + ledger = engine._adams.ledger + record = ( + [tuple(attempt[:4]) for attempt in engine._history], + (ledger.startup, ledger.predictor, ledger.rejected, ledger.accepted_steps), + (ledger.rejected_steps, ledger.restarts, ledger.failure_restarts), + list(ledger.orders), + ) + engine.close() + return field, record + + +@pytest.mark.parametrize( + ("case", "fraction"), + [("rdw", 0.002), ("argon_blueshift", 0.002), ("ctc_reduced", 0.002)], +) +def test_julia_march_is_the_python_march(runtime, monkeypatch, case, fraction): + """Julia's Adams march takes the Python march's decisions on the same engine. + + The same attempts, ledger and accepted orders, and the same field bit for bit; + estimated FFT plans, since a measured plan may differ from one process to the next. + """ + del runtime + monkeypatch.setenv("SOLPROP_FFTW_PLAN", "estimate") + configuration = CASES[case].configuration( + "default", 2, "julia", fraction=fraction, noise="none" + ) + field, record = _march(configuration, "julia") + reference, reference_record = _march(configuration, "host") + assert record == reference_record + np.testing.assert_array_equal(field, reference) From 355b0245354e933997f91c9c75617c3dc4fa2be1 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 00:06:18 +0000 Subject: [PATCH 033/107] Julia: the final A/B rows, the march, and the findings' issues in the docs [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- docs/dev/benchmarks.md | 74 ++++++++++++++++++--------------- docs/guide/performance/julia.md | 13 +++--- julia/STATUS.md | 60 +++++++++++--------------- 3 files changed, 73 insertions(+), 74 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 655e15888..aa5e0aaf5 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -2909,46 +2909,52 @@ The experimental `julia` backend (`julia/STATUS.md`) against `native`, both arms interpreter, `python -m benchmarks ab --baseline-backend native --candidate-backend julia --noise none --length 0.02 --stepper default`: 2 % of each case, so ten to two hundred steps and the cases' 4 to 12 saved planes; the ratio is `julia`/`native`, below one -`julia` faster. Every row took the same steps on both arms, with fields equal to 1e-13 -or better, unless said. These are short windows: they carry the planes' host statistics -and a first-run cost both arms pay (`simulation.metadata()` inside the timed window, -about 0.18 s on `rdw`), and they are not whole runs. +`julia` faster. Every binary64 row took the same steps on both arms, with fields equal +to 1e-13 or better. These are short windows, not whole runs. + +Rows before commit `3969a00c`'s harness fix (#557) timed `simulation.metadata()` inside +the window, about 0.18 s on `rdw`, on both arms: they understate both arms' speed and +overstate how close `julia` was. Native's `rdw` window on 16 Xeon threads is 0.145 s, +not 0.314 s; on the A40 0.054 s, not 0.187 s. **Intel Xeon Gold 6240**, 16 cores of socket 1 with their 16 threads, passive-bound -threading, a shared machine (load about 3), two rounds, commit `3e2290c0`: +threading, a shared machine (load 2 to 14 during the run), two rounds, commit +`7c7ac9b7`: | case | native 1 thread, s | julia | ratio | native 16 threads, s | julia | ratio | |---|---:|---:|---:|---:|---:|---:| -| `rdw` | 0.586 | 0.902 | 1.54 | 0.314 | 0.421 | 1.34 | -| `argon_blueshift` | 0.591 | 1.438 | 2.43 | 0.228 | 0.551 | 2.41 | -| `h2_raman_6ps` | 3.512 | 4.179 | 1.19 | 2.039 | 2.194 | 1.08 | -| `ctc_reduced` | 1.075 | 2.865 | 2.67 | 0.451 | 0.642 | 1.42 | -| `radial_filament_256` | 2.158 | 3.471 | 1.61 | 0.385 | 1.182 | 3.07 | -| `kerr_beam_192` | 5.135 | 6.751 | 1.31 | 0.843 | 2.697 | 3.20 | -| `line` | 0.692 | 0.965 | 1.39 | 0.200 | 0.361 | 1.81 | - -The geometric mean was 2.30 at commit `8ab6c4b9`, before the transverse edge and the -state copies moved into the engine and before the first window's compilation moved to -construction, and 1.78 here. Later commits take a Cartesian 192² window from 1.72 to -1.10 s and a radial one from 0.97 to 0.86 s (single runs, 16 threads, the same socket). +| `rdw` | 0.416 | 0.586 | 1.41 | 0.159 | 0.161 | 1.03 | +| `argon_blueshift` | 0.546 | 1.317 | 2.41 | 0.225 | 0.386 | 1.79 | +| `h2_raman_6ps` | 3.896 | 3.910 | 1.02 | 2.609 | 2.735 | 1.13 | +| `ctc_reduced` | 0.995 | 1.743 | 1.75 | 0.377 | 0.379 | 1.01 | +| `radial_filament_256` | 2.150 | 2.329 | 1.08 | 0.364 | 0.779 | 2.14 | +| `kerr_beam_192` | 5.177 | 5.907 | 1.14 | 0.851 | 1.424 | 1.67 | +| `line` | 0.674 | 0.875 | 1.30 | 0.202 | 0.352 | 1.78 | + +Geometric mean 1.42. The rounds of `argon_blueshift` (1.4 to 2.2 on 16 threads) and +`h2_raman_6ps` (0.8 to 1.4) spread with the machine's load. At commit `09a60bf6`, +before the vectorised plasma and the batched transforms, the same plan gave 1.64. The +next commit, `207add18`, runs the Adams march in the engine: `argon_blueshift` on 16 +threads 0.42 s -> 0.34 s and `rdw` 0.157 -> 0.148 s (single profiled runs, socket 0). **NVIDIA A40** (driver 595.71), native's CUDA build (AMPERE86) against `julia` with -`SOLPROP_JULIA_DEVICE=cuda` (CUDA.jl 6.5), `--device`, two rounds, binary64: +`SOLPROP_JULIA_DEVICE=cuda` (CUDA.jl 6.5), `--device`, two rounds, commit `7c7ac9b7`: -| case | native, s | julia, s at `aa6b9478` | ratio | julia, s at `90840a43` | ratio | +| case | native, s | julia binary64, s | ratio | julia binary32, s | ratio | |---|---:|---:|---:|---:|---:| -| `rdw` | 0.187 | 0.585 | 3.13 | 0.356 | 1.84 | -| `argon_blueshift` | 0.152 | 0.693 | 4.55 | 0.528 | 3.43 | -| `h2_raman_6ps` | 1.127 | 1.501 | 1.33 | 1.515 | 1.33 | -| `ctc_reduced` | 0.266 | | | 0.462 | 1.74 | -| `radial_filament_256` | 0.188 | 0.872 | 4.64 | 0.799 | 4.35 | -| `kerr_beam_192` | 0.203 | 1.513 | 7.47 | 0.662 | 3.62 | -| `line` | 0.112 | 0.354 | 3.19 | 0.325 | 2.98 | - -Between them: the observation populations a sample a thread (they were 70 % of an -`rdw` window's GPU time, one 20 ms kernel a column), the bridge's state copies and an -empty statistics spec's copy. What remains on the A40, from Nsight Systems: binary64 -GEMMs are half of a radial window's device time, the synthesis and projections at -the fine grid's 1728 real rows; FFTs a third of `argon_blueshift`'s, about eight a -source; and host work per step and per plane, which the binary64 kernels do not -explain (`rdw`: 0.14 s on the device in a 0.36 s window). +| `rdw` | 0.054 | 0.168 | 3.13 | 0.181 | 3.38 | +| `argon_blueshift` | 0.115 | 0.444 | 3.85 | 0.313 | 2.72 | +| `h2_raman_6ps` | 1.040 | 1.310 | 1.26 | 1.005 | 0.96 | +| `ctc_reduced` | 0.206 | 0.386 | 1.87 | 0.352 | 1.71 | +| `radial_filament_256` | 0.169 | 0.628 | 3.73 | 0.547 | 3.24 | +| `kerr_beam_192` | 0.173 | 0.618 | 3.58 | 0.611 | 3.50 | +| `line` | 0.094 | 0.311 | 3.30 | 0.294 | 3.12 | + +Geometric means 2.77 (binary64) and 2.45 (binary32 against native's binary64; its +fields within 4e-7 to 1.4e-5 of native's, and `rdw`, `ctc_reduced` and the radial +window take other steps). At `90840a43`, with the metadata inside the window, the +binary64 mean was 2.54 and `rdw` 0.356 s. What remains on the A40, from Nsight +Systems (`rdw`, commit `7c7ac9b7`): the device is busy for about 124 ms of the 0.168 s +window. Nine transforms a source at 96 us each (over four modes, so a few blocks each: +latency, not work) are a third; the Adams predictor's reduction, heavy binary64 work a +sample on too few threads, 539 us a trial; then the plasma and Kerr passes. diff --git a/docs/guide/performance/julia.md b/docs/guide/performance/julia.md index ae8f60165..389349258 100644 --- a/docs/guide/performance/julia.md +++ b/docs/guide/performance/julia.md @@ -41,7 +41,9 @@ running contiguous SIMD loops; on a GPU, a KernelAbstractions kernel a sample a FFTs are AbstractFFTs plans (FFTW or cuFFT) and contractions `mul!` (BLAS or cuBLAS). On a CPU one pool runs everything, the transforms as blocks of single-threaded plans and the products as blocks of rows, because the libraries' own threads beside the pool's -made a run slower on four threads than on one. In binary32 the state is held as +made a run slower on four threads than on one. The plasma's columns use branch-free +vectorised `exp` and `log` within one ulp, and the exponential Adams march itself runs +in the engine, as native's compiled march does. In binary32 the state is held as `a / s` for SEP 33's power-of-two scale `s`, and the operator stays binary64, so propagators and the longitudinal root are formed in binary64 and rounded once. @@ -50,7 +52,8 @@ propagators and the longitudinal root are formed in binary64 and rounded once. Indicative only: short windows of the benchmark cases, measured with `python -m benchmarks ab` against native on the same machine. The branch's ledger ([benchmarks](../../dev/benchmarks.md#julia-backend-experiment)) has the numbers, the -machines and the commits. On CPUs the julia backend is within one to three times -native's time; on an NVIDIA A40 within one to four times native's CUDA build. Most of -what is left is host work per step and per saved plane, which native does in compiled -code: the Adams march and the statistics. +machines and the commits. On a 16-core Xeon the julia backend takes 1.0 to 2.1 times +native's time (geometric mean 1.4), at parity on the `rdw` and `ctc_reduced` capillary +windows; on an NVIDIA A40 in binary64, 1.3 to 3.9 times native's CUDA build. What is +left is mostly the GPU's transforms and launches, and on a CPU the radial and +Cartesian routes' many threads. diff --git a/julia/STATUS.md b/julia/STATUS.md index 54d1bb4db..8bfe2ab8e 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -44,6 +44,7 @@ Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless | The Poynting statistics' transforms and the populations in the engine, without allocating | `rdw` statistics 55 ms -> 40 ms; collector pauses (13 to 83 ms) gone | | A plasma column's live samples gathered; vectorised `exp` and `log` (`src/vmath.jl`, 1 ulp) | argon's plasma on one thread 4.7 ms -> 2.9 ms a source | | A source's forward transforms, and the quadrature alarm's, as one pool's work | `rdw` on 16 threads: commits 12.3 ms -> 5.8 ms, the source's transforms 8.7 ms -> 3.8 ms | +| The exponential Adams march in the engine (`src/march.jl`, native's SEP 39 march transcribed) | `argon_blueshift` on 16 threads 0.42 s -> 0.34 s; the Python march's decisions bit for bit | The vectorised functions paid only once the live samples were gathered and each pass was a function of its own: in the column's branchy loop, and inside its closure, LLVM @@ -53,41 +54,29 @@ rate is a vectorised `log`, the lookup and a vectorised `exp`, three passes. ## Where it stands Julia's window time over native's, 2 % of each case, both arms in one interpreter, the -same steps and fields equal to rounding (1e-13 or better) unless said. - -**Intel Xeon Gold 6240** (commit `3e2290c0`, socket 1, passive-bound threads): - -| case | 1 thread | 16 threads | -|---|---:|---:| -| rdw | 1.54 | 1.34 | -| argon_blueshift | 2.43 | 2.41 | -| h2_raman_6ps | 1.19 | 1.08 | -| ctc_reduced | 2.67 | 1.42 | -| radial_filament_256 | 1.61 | 3.07 | -| kerr_beam_192 | 1.31 | 3.20 | -| line | 1.39 | 1.81 | - -**NVIDIA A40** against native's CUDA build (commit `90840a43`, binary64): - -| case | ratio | -|---|---:| -| rdw | 1.84 | -| argon_blueshift | 3.43 | -| h2_raman_6ps | 1.33 | -| ctc_reduced | 1.74 | -| radial_filament_256 | 4.35 | -| kerr_beam_192 | 3.62 | -| line | 2.98 | - -The AMD EPYC 7763 and binary32 rows are in the ledger. +same steps and fields equal to rounding (1e-13 or better); the ledger has the seconds. + +| case | Xeon, 1 thread | Xeon, 16 threads | A40, binary64 | A40, binary32 | +|---|---:|---:|---:|---:| +| rdw | 1.41 | 1.03 | 3.13 | 3.38 | +| argon_blueshift | 2.41 | 1.79 | 3.85 | 2.72 | +| h2_raman_6ps | 1.02 | 1.13 | 1.26 | 0.96 | +| ctc_reduced | 1.75 | 1.01 | 1.87 | 1.71 | +| radial_filament_256 | 1.08 | 2.14 | 3.73 | 3.24 | +| kerr_beam_192 | 1.14 | 1.67 | 3.58 | 3.50 | +| line | 1.30 | 1.78 | 3.30 | 3.12 | + +Intel Xeon Gold 6240 (16 cores of socket 1, a shared machine) and NVIDIA A40 against +native's CUDA build, both at commit `7c7ac9b7`; geometric means 1.42, 2.77 and 2.45. The +next commit's Julia march takes `argon_blueshift` on 16 threads from 0.42 s to 0.34 s. +Binary32 is against native's binary64. Ratios measured before the harness fix (#557) +counted 0.18 s of metadata on both arms and are not comparable. ## What is left, measured -- **The march in Python.** The Adams controller's decisions and the bridge's calls - between them: about 0.37 ms a step on the Xeon (`argon_blueshift` on 16 threads: - 0.08 s of a 0.40 s window, 213 steps; native's whole step is 0.86 ms). A Julia march - (native's SEP 39, with its decision-trace tests as the oracle) would remove it; the - tables and stage scalars it needs are in the engine already. +- **The march's host events.** The Adams march runs in the engine (`src/march.jl`) + and returns at each plane, monitor check and statistics row; a split collar, a + replayed schedule and interpolated planes keep the Python march. - **Host statistics per plane.** The spectra and the reductions over the engine's power are the shared host functions: about 1.4 ms a plane on `rdw`. - **Small states on many threads.** With one mode and 1601 bins the passes are serial @@ -109,14 +98,15 @@ planes are refused by name. ## Findings for main - `parallel_rows` read the CPU topology from sysfs (a file per CPU) before deciding a - pass was too small to thread: 60 ms of a 0.36 s rdw window. Fixed on this branch. + pass was too small to thread: 60 ms of a 0.36 s rdw window. Fixed on this branch; + #556. - `benchmarks.worker.timed_run` evaluated `simulation.metadata()` inside the timed window, and its first evaluation costs about 0.18 s on rdw (the plane bases' modal identity): every arm's first timed repeat, native's included, paid it. Fixed on this branch; ratios measured before it understate both arms' speed (native's `rdw` window - on 16 threads is 0.145 s, not 0.314 s). + on 16 threads is 0.145 s, not 0.314 s); #557. - Julia's LinearAlgebra gave wrong products for concurrent `mul!` calls on views of a `Complex{Float32}` matrix times a `Float32` one (relative error 1.5); the engine forms them as real GEMMs over the complex array's real view instead. - `docs/dev/backends.md` still names `set_held_plane` and `held_observation`, which - main removed. + main removed; #558. From 9d0180e0b5ba394da7ae4b21fe7d7966222a2d16 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 00:15:13 +0000 Subject: [PATCH 034/107] Julia: an AMDGPU extension and its environment [skip ci] ROCArrays, rocFFT plans and rocBLAS products for SOLPROP_JULIA_DEVICE=rocm, in julia/rocm (AMDGPU.jl 2.11 resolved with the engine), bootstrapped with --rocm; the benchmark worker keeps rocm under --device. Every plan kind the engine forms has a ROCArray method and the extension loads; not yet run on an AMD GPU. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- benchmarks/worker.py | 6 +- julia/Project.toml | 2 + julia/README.md | 7 +- julia/bootstrap.py | 7 +- julia/cuda/Manifest.toml | 6 +- julia/ext/SolpropJuliaAMDGPUExt.jl | 13 + julia/rocm/Manifest.toml | 1056 ++++++++++++++++++++++++ julia/rocm/Project.toml | 7 + src/solprop/backends/julia/_runtime.py | 18 +- 9 files changed, 1108 insertions(+), 14 deletions(-) create mode 100644 julia/ext/SolpropJuliaAMDGPUExt.jl create mode 100644 julia/rocm/Manifest.toml create mode 100644 julia/rocm/Project.toml diff --git a/benchmarks/worker.py b/benchmarks/worker.py index a49b9a1ac..7610ecacf 100644 --- a/benchmarks/worker.py +++ b/benchmarks/worker.py @@ -98,7 +98,11 @@ def runtime(backend: str, device: bool = False) -> Record: if backend == "julia": # The Julia experiment runs on its CUDA device under --device; its sources # are identified by digest, as a native build is by its extension's. - os.environ["SOLPROP_JULIA_DEVICE"] = "cuda" if device else "cpu" + # A GPU run takes the GPU the environment names (rocm on AMD), else CUDA. + named = os.environ.get("SOLPROP_JULIA_DEVICE") + os.environ["SOLPROP_JULIA_DEVICE"] = ( + (named if named in {"cuda", "rocm"} else "cuda") if device else "cpu" + ) from solprop.backends.julia import source_digest # noqa: PLC0415 info["julia_build"] = source_digest() diff --git a/julia/Project.toml b/julia/Project.toml index c62530a5e..aba704e28 100644 --- a/julia/Project.toml +++ b/julia/Project.toml @@ -11,9 +11,11 @@ Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" [weakdeps] +AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" [extensions] +SolpropJuliaAMDGPUExt = "AMDGPU" SolpropJuliaCUDAExt = "CUDA" [compat] diff --git a/julia/README.md b/julia/README.md index 83950f83a..bb89214f9 100644 --- a/julia/README.md +++ b/julia/README.md @@ -21,8 +21,10 @@ controller and the output are solprop's own. The engine is the Julia package in | `dopri.jl`, `rk4.jl`, `adams.jl` | the DOPRI5 trial and commit, SEP 24's RK4IP and SEP 16's exponential Adams | | `helpers.jl` | the shared code's Chebyshev rows and Adams basis (SEP 29 section 6.6), and an Adams trial's tables | | `stages.jl` | the longitudinal expansions' stage weights, and the stage scalars from the engine's own tables | +| `march.jl` | the exponential Adams march itself (native's SEP 39 march, transcribed), run by the engine between host events | | `observe.jl` | what the driver reads between steps: the state, the boundary monitor's and the transverse edge's sums, the Poynting statistics' power | | `../ext/SolpropJuliaCUDAExt.jl` | CUDA: the engine's arrays become `CuArray`s | +| `../ext/SolpropJuliaAMDGPUExt.jl` | AMD GPUs: the engine's arrays become `ROCArray`s | ## Setting up @@ -32,7 +34,7 @@ checksummed release): ```sh uv sync --extra julia export SOLPROP_JULIA_EXE=$(julia +1.13 -e 'print(joinpath(Sys.BINDIR, "julia"))') -uv run --no-sync python julia/bootstrap.py # --cuda for the GPU environment too +uv run --no-sync python julia/bootstrap.py # --cuda or --rocm for a GPU environment too ``` The bootstrap instantiates `julia/Manifest.toml` into `.julia-depot/` @@ -42,7 +44,8 @@ solprop is installed without `-e`. A run then takes `backend="julia"`: | Variable | Meaning | |---|---| | `SOLPROP_JULIA_THREADS` | the engine's threads (default 1); the benchmark harness sets it to the width | -| `SOLPROP_JULIA_DEVICE` | `cpu` (default) or `cuda`, which loads `julia/cuda`: CUDA.jl resolved with the engine | +| `SOLPROP_JULIA_DEVICE` | `cpu` (default), `cuda` or `rocm`, which load `julia/cuda` or `julia/rocm`: CUDA.jl or AMDGPU.jl resolved with the engine | +| `SOLPROP_JULIA_MARCH` | `host`: the Python Adams march in place of the engine's (`src/march.jl`) | | `SOLPROP_FFTW_PLAN` | `estimate`, `measure` (default) or `patient` | | `SOLPROP_JULIA_TIMING` | `1`: the engine's section timers (`julia/profile.py` prints them) | | `SOLPROP_JULIA_CHECK` | `1`: refuse any kernel body a GPU could not take, on any device (the tests set it) | diff --git a/julia/bootstrap.py b/julia/bootstrap.py index 1ff3e1aab..e28fcea92 100644 --- a/julia/bootstrap.py +++ b/julia/bootstrap.py @@ -75,8 +75,11 @@ def main() -> None: "JULIA_CONDAPKG_BACKEND": "Null", "JULIA_PYTHONCALL_EXE": sys.executable, } - # --cuda also prepares the GPU environment, which adds CUDA.jl to the engine's. - projects = ["julia", "julia/cuda"] if "--cuda" in sys.argv[1:] else ["julia"] + # --cuda (--rocm) also prepares the GPU environment, which adds CUDA.jl (AMDGPU.jl) + # to the engine's. + projects = ["julia"] + [ + f"julia/{gpu}" for gpu in ("cuda", "rocm") if f"--{gpu}" in sys.argv[1:] + ] for project in projects: subprocess.run( [ diff --git a/julia/cuda/Manifest.toml b/julia/cuda/Manifest.toml index 9ca39d7e8..3b7bd16b4 100644 --- a/julia/cuda/Manifest.toml +++ b/julia/cuda/Manifest.toml @@ -874,11 +874,15 @@ deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlg path = ".." uuid = "bc9db228-6fd1-46b1-b175-748485922872" version = "0.0.0" -weakdeps = ["CUDA"] [deps.SolpropJulia.extensions] + SolpropJuliaAMDGPUExt = "AMDGPU" SolpropJuliaCUDAExt = "CUDA" + [deps.SolpropJulia.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + [[deps.SparseArrays]] deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" diff --git a/julia/ext/SolpropJuliaAMDGPUExt.jl b/julia/ext/SolpropJuliaAMDGPUExt.jl new file mode 100644 index 000000000..aff469e44 --- /dev/null +++ b/julia/ext/SolpropJuliaAMDGPUExt.jl @@ -0,0 +1,13 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# AMD GPUs: the engine's arrays become ROCArrays, its transforms rocFFT plans and its +# products rocBLAS calls; every pass is the same scalar body as on a CPU or an NVIDIA GPU. +module SolpropJuliaAMDGPUExt +using AMDGPU +import SolpropJulia + +SolpropJulia.device_backend(::Val{:rocm}) = (AMDGPU.allowscalar(false); ROCBackend()) +SolpropJulia.device_label(::ROCBackend) = "rocm: " * string(AMDGPU.device()) + +end diff --git a/julia/rocm/Manifest.toml b/julia/rocm/Manifest.toml new file mode 100644 index 000000000..18a09e28f --- /dev/null +++ b/julia/rocm/Manifest.toml @@ -0,0 +1,1056 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "ca8f3b16813e914ee06733138c49801ce1bb645a" + +[[deps.AMDGPU]] +deps = ["AMDGPU_LLVM_Backend_jll", "AbstractFFTs", "Adapt", "Atomix", "BFloat16s", "CEnum", "GPUArrays", "GPUCompiler", "GPUToolbox", "KernelAbstractions", "KernelInterface", "LLVM", "LLVMDowngrader_jll", "Libdl", "LinearAlgebra", "PrecompileTools", "Preferences", "PrettyTables", "Printf", "Random", "Random123", "RandomNumbers", "Scratch", "SparseArrays", "Statistics", "UnsafeAtomics"] +git-tree-sha1 = "339be76666103bf8a2c7b2dd638a80336e9b1fda" +registries = "General" +uuid = "21141c5a-9bdb-4563-92ae-f87d6854732e" +version = "2.11.0" + + [deps.AMDGPU.extensions] + AMDGPUChainRulesCoreExt = "ChainRulesCore" + AMDGPUEnzymeCoreExt = "EnzymeCore" + AMDGPUSparseMatricesCSRExt = "SparseMatricesCSR" + AMDGPUSpecialFunctionsExt = "SpecialFunctions" + + [deps.AMDGPU.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + SparseMatricesCSR = "a0a7dd2c-ebf4-11e9-1f05-cf50bc540ca1" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.AMDGPU_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "b93538105521d4f4432495c16f4d88b8e071dd23" +registries = "General" +uuid = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" +version = "23.1.3+1" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + +[[deps.BFloat16s]] +deps = ["LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "59ba860cf4d7e2fe58f35c8d08cfe765b6c33655" +registries = "General" +uuid = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" +version = "0.6.5" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CondaPkg]] +deps = ["FileWatching", "JSON", "Markdown", "MicroMamba", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "5105aafa8fedef75ad7f44d7dbf85a1b7196e406" +registries = "General" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.38" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Crayons]] +git-tree-sha1 = "54b76cbb40d9a0f5368c880725b2f141da77c94f" +registries = "General" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.2.0" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArrays]] +deps = ["AcceleratedKernels", "Adapt", "GPUArraysCore", "KernelAbstractions", "LLVM", "LinearAlgebra", "Printf", "Random", "Reexport", "ScopedValues", "Serialization", "SparseArrays", "Statistics"] +git-tree-sha1 = "1cd2703c11e873a60d0182b6806217a26d71d252" +registries = "General" +uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" +version = "12.2.0" + + [deps.GPUArrays.extensions] + JLD2Ext = "JLD2" + + [deps.GPUArrays.weakdeps] + JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" +weakdeps = ["BFloat16s"] + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + +[[deps.LLVMDowngrader_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "2db47bc5100d848d977608dbf58fb7ceea1ffa4f" +registries = "General" +uuid = "f52de702-fb25-5922-94ba-81dd59b07444" +version = "0.12.2+0" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "f88f3ccef05a6a72a0cf0ed417c8fd68530f4ab2" +registries = "General" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.1" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +registries = "General" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "b079a6affebde167dad8ffe0d670b53917fbcb68" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "2.0.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "StyledStrings", "Tables"] +git-tree-sha1 = "eeac4c9337f876c3c32b8da732141953567f57c9" +registries = "General" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.5.1" + + [deps.PrettyTables.extensions] + PrettyTablesExcelExt = "XLSX" + PrettyTablesTypstryExt = "Typstry" + PrettyTablesWriteDocxExt = "WriteDocx" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + WriteDocx = "d049ceea-54ee-41d7-a26f-ba29db3b6599" + XLSX = "fdbf4ff8-1666-58a4-91e7-1b58723a45e0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Preferences", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "00d3a883b716a8482da76d08dae1f6084bbfeb23" +registries = "General" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.37" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "6aaddfdf3040d02a5b3e10c6cd0e4e1dce27f23c" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+1" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SolpropJulia]] +deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +path = ".." +uuid = "bc9db228-6fd1-46b1-b175-748485922872" +version = "0.0.0" + + [deps.SolpropJulia.extensions] + SolpropJuliaAMDGPUExt = "AMDGPU" + SolpropJuliaCUDAExt = "CUDA" + + [deps.SolpropJulia.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.13.0" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StringManipulation]] +deps = ["PrecompileTools", "StyledStrings"] +git-tree-sha1 = "9e3a02d73a8f0a9be04e677dbef758aab40f8bea" +registries = "General" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.6.1" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.10.1+0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +registries = "General" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +registries = "General" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "56c56fede8f01e1be7e2fdf1eb911487640619a0" +registries = "General" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.76.2+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/rocm/Project.toml b/julia/rocm/Project.toml new file mode 100644 index 000000000..b24348e33 --- /dev/null +++ b/julia/rocm/Project.toml @@ -0,0 +1,7 @@ +[deps] +AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +SolpropJulia = "bc9db228-6fd1-46b1-b175-748485922872" + +[sources] +SolpropJulia = {path = ".."} diff --git a/src/solprop/backends/julia/_runtime.py b/src/solprop/backends/julia/_runtime.py index aaf29f621..c2c43eab9 100644 --- a/src/solprop/backends/julia/_runtime.py +++ b/src/solprop/backends/julia/_runtime.py @@ -82,8 +82,8 @@ def runtime() -> Any: ``SOLPROP_JULIA_EXE`` names the Julia 1.13 executable (default: the one ``julia/bootstrap.py`` downloads), ``SOLPROP_JULIA_DEPOT`` its package depot (default ``.julia-depot``) and ``SOLPROP_JULIA_ROOT`` the checkout (`checkout`). - ``SOLPROP_JULIA_DEVICE=cuda`` loads the CUDA environment, so that the engine's CUDA - extension is available. + ``SOLPROP_JULIA_DEVICE=cuda`` (or ``rocm``) loads the CUDA (or AMDGPU) environment, + so that the engine's GPU extension is available. Returns ------- @@ -112,12 +112,12 @@ def runtime() -> Any: "follow julia/README.md" ) device = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") - if device not in {"cpu", "cuda"}: - raise BackendError("SOLPROP_JULIA_DEVICE must be cpu or cuda") - # A GPU run's environment adds CUDA.jl to the engine's, resolved with it, so - # that a CPU run never resolves or loads the GPU packages. - if device == "cuda": - project = project / "cuda" + if device not in {"cpu", "cuda", "rocm"}: + raise BackendError("SOLPROP_JULIA_DEVICE must be cpu, cuda or rocm") + # A GPU run's environment adds CUDA.jl or AMDGPU.jl to the engine's, resolved + # with it, so that a CPU run never resolves or loads the GPU packages. + if device != "cpu": + project = project / device settings = { "PYTHON_JULIACALL_EXE": str(executable), "PYTHON_JULIACALL_PROJECT": str(project), @@ -182,6 +182,8 @@ def source_digest() -> str: root / "julia/Manifest.toml", root / "julia/cuda/Project.toml", root / "julia/cuda/Manifest.toml", + root / "julia/rocm/Project.toml", + root / "julia/rocm/Manifest.toml", ] ) adapter = sorted(Path(__file__).parent.glob("*.py")) From bd021ce2021b2ed5a5f9ee43c6846ce40e08e500 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 00:36:43 +0000 Subject: [PATCH 035/107] Julia: radial and free planes' local statistics in the engine [skip ci] collect_spatial's energy, on-axis and local statistics for a radial or free plane: the local pass's node spectra (the synthesis, or the engine's transverse FFT), analytic signals and fluence sums by the engine (spatial_local!), the energy, on-axis values and widths by the reference's operations, with the plane's admittance kept while the plane is the same object. The windows' statistics still match numpy_ref's to 1e-9. On 16 Xeon threads: radial 0.65 s -> 0.44 s, line 0.27 s -> 0.18 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/STATUS.md | 5 +- julia/src/free.jl | 2 +- julia/src/modal.jl | 2 +- julia/src/observe.jl | 103 ++++++++++++++ src/solprop/backends/julia/_backend.py | 181 +++++++++++++++++++++++-- 5 files changed, 278 insertions(+), 15 deletions(-) diff --git a/julia/STATUS.md b/julia/STATUS.md index 8bfe2ab8e..15245aa46 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -45,6 +45,7 @@ Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless | A plasma column's live samples gathered; vectorised `exp` and `log` (`src/vmath.jl`, 1 ulp) | argon's plasma on one thread 4.7 ms -> 2.9 ms a source | | A source's forward transforms, and the quadrature alarm's, as one pool's work | `rdw` on 16 threads: commits 12.3 ms -> 5.8 ms, the source's transforms 8.7 ms -> 3.8 ms | | The exponential Adams march in the engine (`src/march.jl`, native's SEP 39 march transcribed) | `argon_blueshift` on 16 threads 0.42 s -> 0.34 s; the Python march's decisions bit for bit | +| Radial and free planes' local statistics in the engine; the plane's admittance kept | radial on 16 threads 0.65 s -> 0.44 s, `line` 0.27 s -> 0.18 s (native's 0.20 s) | The vectorised functions paid only once the live samples were gathered and each pass was a function of its own: in the column's branchy loop, and inside its closure, LLVM @@ -77,8 +78,8 @@ counted 0.18 s of metadata on both arms and are not comparable. - **The march's host events.** The Adams march runs in the engine (`src/march.jl`) and returns at each plane, monitor check and statistics row; a split collar, a replayed schedule and interpolated planes keep the Python march. -- **Host statistics per plane.** The spectra and the reductions over the engine's power - are the shared host functions: about 1.4 ms a plane on `rdw`. +- **Host statistics per plane.** The spectra, and the reductions over the engine's + power and fluence, are the shared host functions: about 1.4 ms a plane on `rdw`. - **Small states on many threads.** With one mode and 1601 bins the passes are serial by size, and run 20 to 40 % slower with 16 cores busy than with one (the clock). - **Serial plasma integrals.** The two running integrals are sequential by design. diff --git a/julia/src/free.jl b/julia/src/free.jl index 3e6150254..c755d7704 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -46,7 +46,7 @@ function create_free(c, host) coarse, coarse_spec = dzeros(c, R, nc, chunk), dzeros(c, C, nw, chunk) planes = (threads=c.transverse_fft_threads, batch=1) work = ( - adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), + adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), plasma=plasma_workspace(c, host, nt, chunk, chunk, nm), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 57f61d226..eb67c775b 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -76,7 +76,7 @@ function create_modal(c, host) node_forward=spectral ? plan(c, plan_rfft, nodes, 1) : nothing, absorber_spec_band=dzeros(c, C, spectral && in_stage ? nw : 0, spectral && in_stage ? nm : 0), adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), - monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), statistics=Ref{Any}(nothing), + monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), statistics=Ref{Any}(nothing), raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), diff --git a/julia/src/observe.jl b/julia/src/observe.jl index 86ba7e0bb..def295f3c 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -289,3 +289,106 @@ end const bind_poynting_b = bind_poynting! const poynting_b = poynting! + +# --- the spatial routes' local statistics -------------------------------------------- + +"""Hold the spatial local statistics' buffers and tables: the closure's factor, the +conjugate axial admittance (`closure`, (n_omega, n_modes)), and a modal transform's +synthesis over the pad scale (`synthesis`, (n_nodes, n_modes)); a free transform's +nodes are its inverse transverse FFT. `chunk` nodes are transformed at a time.""" +function bind_spatial!(engine, closure, synthesis, chunk) + c, w = engine.config, engine.work + T = real_type(engine) + C = Complex{T} + nw, nm = size(w.y) + s = w.spatial[] + if s === nothing + S = synthesis === nothing ? nothing : + upload(c, T.(permutedims(Matrix{Float64}(synthesis)))) + nn = S === nothing ? nm : size(S, 2) + width = min(Int(chunk), nn) + signal = dzeros(c, C, c.nc, width) + s = (closure=dzeros(c, C, nw, nm), S=S, electric=dzeros(c, C, nw, nn), + magnetic=dzeros(c, C, nw, nn), weighted=dzeros(c, C, nw, nm), signal=signal, + other=dzeros(c, C, c.nc, width), inverse=plan(c, plan_bfft!, signal, 1), + fluence=dzeros(c, T, nn), magnitudes=dzeros(c, T, nn), peaks=dzeros(c, T, nn)) + w.spatial[] = s + end + copyto!(s.closure, C.(Matrix{ComplexF64}(closure))) + nothing +end + +"""The nodes' spectra of a modal-domain matrix `x` (n_omega, n_modes) into `nodes`.""" +function node_spectra!(nodes, x, s, engine) + c = engine.config + if s.S === nothing + copyto!(nodes, x) + transverse!(nodes, engine.work.spatial_inverse, c) + else + gemm!(nodes, x, s.S, true, false, c) + end +end + +"""`backends.spatial._local_statistics`'s transforms and sums, by the engine. + +Each node's field and closure (the field times the conjugate admittance) as analytic +signals, their cycle-averaged Poynting flux `I(t) = 0.5 eps0 c Re(E conj(H))`, and per +node its fluence `dt sum_t I`, the magnitude `0.5 eps0 c dt sum_t |E||H|` and the peak +of `I`. Returns the three per-node arrays (the reference's own forms the widths).""" +function spatial_local!(engine, dt, conversion) + c, w = engine.config, engine.work + s = w.spatial[] + T = real_type(engine) + y = w.y + (; closure, weighted, electric, magnetic, signal, other, fluence, magnitudes, peaks) = s + each!(c, size(y)...) do k, m + @inbounds weighted[k, m] = y[k, m] * closure[k, m] + end + node_spectra!(electric, y, s, engine) + node_spectra!(magnetic, weighted, s, engine) + nw, nn = size(electric) + nt, width = size(signal) + # numpy's 1/n_t on each inverse, the state's scale, a free transform's 1/N. + points = s.S === nothing ? prod(c.spatial_shape) : 1 + factor = T((c.scale / (nt * points))^2) + flux, step = T(conversion), T(dt) + envelope, nyquist = c.envelope, nt ÷ 2 + 1 + two, none, start, lowest = T(2), zero(Complex{T}), zero(T), T(-Inf) + for first in 1:width:nn + count = min(width, nn - first + 1) + for (target, source) in ((signal, electric), (other, magnetic)) + each!(c, nt, width) do k, n + @inbounds begin + value = k <= nw && n <= count ? source[k, first+n-1] : none + if !envelope + value = k == 1 || k == nyquist ? complex(real(value)) : + k < nyquist ? two * value : none + end + target[k, n] = value + end + end + s.inverse * target + end + each_column!(c, count) do n + total, magnitude, peak = start, start, lowest + @inbounds for t in 1:nt + e, h = signal[t, n], other[t, n] + intensity = flux * real(e * conj(h)) * factor + total += intensity + magnitude += abs(e) * abs(h) * factor + peak = max(peak, intensity) + end + @inbounds begin + fluence[first+n-1] = step * total + magnitudes[first+n-1] = flux * step * magnitude + peaks[first+n-1] = peak + end + nothing + end + end + (Vector{Float64}(Array(fluence)), Vector{Float64}(Array(magnitudes)), + Vector{Float64}(Array(peaks))) +end + +const bind_spatial_b = bind_spatial! +const spatial_local_b = spatial_local! diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index cb9cc9392..8fde158e2 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -13,6 +13,7 @@ import numpy as np from jaxtyping import Complex +from solprop import fourier from solprop._process import _BlasLease from solprop.backends.driver import StepDriver, refuse_general_leaves from solprop.backends.exponential import refuse_carrier_frame @@ -26,7 +27,13 @@ ) from solprop.backends.multistep import source_absent from solprop.backends.numpy_ref.passes import plasma_integration_statistics -from solprop.backends.spatial import collect_spatial, radial_absorber_matrix +from solprop.backends.spatial import ( + _axis_statistics, # pyright: ignore[reportPrivateUsage] - the reference's own form + collect_spatial, + fluence_budget, + radial_absorber_matrix, + signed_fluence_widths, +) from solprop.constants import EPS0, C from solprop.exceptions import BackendError from solprop.grid import TimeGrid @@ -49,6 +56,7 @@ from solprop.translate.linop import power_weight_at from solprop.translate.precision import launch_peak, state_scale from solprop.translate.problem import KernelProblem +from solprop.translate.spatial import axial_admittance from solprop.translate.stage import terms from solprop.transverse_monitor import TransverseEdge, _EdgeReading @@ -80,6 +88,14 @@ ) +_SPATIAL_LOCAL = frozenset(("peak_intensity", "beam_radius", "fwhm_r")) +_SPATIAL_AXIS = frozenset( + ("on_axis_spectrum", "on_axis_intensity", "beam_radius", "fwhm_r") +) +_SPATIAL_OWNED = frozenset(("energy",)) | _SPATIAL_LOCAL | _SPATIAL_AXIS +"""The spatial statistics the backend forms itself (``JuliaBackend._spatial``).""" + + def _constant(table: PiecewiseChebyshev | None) -> bool: """Check the whole polynomial, not just samples at a few positions. @@ -453,6 +469,8 @@ def __init__( self._threads = thread_limit("SOLPROP_JULIA_THREADS") self._fixed: dict[str, object] | None = None self._poynting_weight: np.ndarray | None = None + self._admittance: tuple[object, np.ndarray] | None = None + self._spatial_plane: object | None = None if not 1 <= self._threads <= int(self._jl.runtime()[1]): raise BackendError("julia thread count must fit the initialized runtime") self._engine = call_julia( @@ -548,6 +566,11 @@ def _warm_bridge(self) -> None: for flux in (False, axis is not None): np.asarray(call_julia(jl.poynting_b, engine, flux)[0]) call_julia(jl.bind_monitor_b, engine, None, None) + zeros = np.zeros((n_modes, 1, n_omega), dtype=np.complex128) + owned = self._spatial_owned(self._problem.stats_spec.names, zeros) + if owned and self._grid is not None: + # The local pass's transforms are planned here, not at the first plane. + self._spatial(owned, self._grid, zeros) self.metadata() def _adams_state(self) -> Complex[np.ndarray, "n_batch n_modes n_pol n_omega"]: @@ -961,16 +984,22 @@ def stats(self, spec: StatsSpec) -> dict[str, np.ndarray]: names=tuple(n for n in spec.names if n not in _SPECIES_STATS), periodic=(), ) - values = collect_spatial( - delegated, - grid, - self._problem.transform, - state, - z=self._z, - flux=self._problem.flux, - profiles=self._profiles, - operator=self._problem.linear.separable, - ) + owned = self._spatial_owned(delegated.names, state) + values = self._spatial(set(delegated.names) & owned, grid, state) + rest = tuple(n for n in delegated.names if n not in owned) + if rest: + values.update( + collect_spatial( + dataclasses.replace(delegated, names=rest), + grid, + self._problem.transform, + state, + z=self._z, + flux=self._problem.flux, + profiles=self._profiles, + operator=self._problem.linear.separable, + ) + ) if _SPECIES_STATS.intersection(spec.names): values.update(self._populations(spec, state)) return {name: value[None] for name, value in values.items()} @@ -1075,6 +1104,136 @@ def _poynting( ) return values + def _spatial_owned(self, names: tuple[str, ...], state: np.ndarray) -> set[str]: + """Return the spatial statistics this backend forms, of those asked. + + A radial or free plane's energy, on-axis and local statistics, for a single + polarisation with the run's plane measure; the rest are ``collect_spatial``'s. + + Parameters + ---------- + names : tuple of str + The statistics asked. + state : numpy.ndarray + The state, (n_modes, n_pol, n_omega). + + Returns + ------- + set of str + The names :meth:`_spatial` forms. + """ + geometry = self._problem.transform.geometry + if ( + geometry is None + or geometry.kind not in ("radial", "free") + or self._problem.flux is None + or state.shape[1] != 1 + ): + return set() + return set(names) & _SPATIAL_OWNED + + def _spatial( + self, names: set[str], grid: TimeGrid, state: np.ndarray + ) -> dict[str, np.ndarray]: + """``collect_spatial``'s energy, on-axis and local statistics. + + The local ones' transforms and sums are the engine's (``spatial_local!``). The + admittance is the plane's, kept while the plane is the same object (a + medium constant in z has one); the energy and the on-axis statistics are the + reference's operations, and the local pass's sums the engine's. + + Parameters + ---------- + names : set of str + The statistics to form, of :data:`_SPATIAL_OWNED`. + grid : solprop.grid.TimeGrid + The run's grid. + state : numpy.ndarray + The state, (n_modes, 1, n_omega). + + Returns + ------- + dict + The statistics, keyed by name. + """ + if not names: + return {} + transform = self._problem.transform + geometry = transform.geometry + flux = self._problem.flux + assert geometry is not None and flux is not None + plane = flux.at(self._z) + if self._admittance is None or self._admittance[0] is not plane: + self._admittance = ( + plane, + axial_admittance(plane, grid.omega, slice(None)), + ) + admittance = self._admittance[1] + values: dict[str, np.ndarray] = {} + conversion = 0.5 * EPS0 * C + chunks = [ + slice(first, min(first + transform.node_chunk, transform.n_modes)) + for first in range(0, transform.n_modes, transform.node_chunk) + ] + if "energy" in names: + weights = fourier.energy_weights(grid.n_omega, grid.dt, kind=grid.kind) + total = 0.0 + for columns in chunks: + real = np.real(admittance[columns]) + density = np.sum(np.abs(state[columns]) ** 2, axis=1) + total += float( + np.sum( + geometry.spectral_weights[columns, None] + * weights + * real + * density + ) + ) + values["energy"] = np.asarray(conversion * total) + axis_fluence = 0.0 + if names & _SPATIAL_AXIS: + closure = np.conj(admittance)[:, None] * state + axis_values, axis_fluence = _axis_statistics( + names, + grid, + np.einsum("r,rpw->pw", geometry.on_axis, state), + np.einsum("r,rpw->pw", geometry.on_axis, closure), + ) + values.update(axis_values) + if names & _SPATIAL_LOCAL: + if self._spatial_plane is not plane: + synthesis = ( + None + if geometry.kind == "free" + else np.ascontiguousarray(transform.synthesis / grid.pad_scale) + ) + call_julia( + self._jl.bind_spatial_b, + self._engine, + np.ascontiguousarray(np.conj(admittance).T), + synthesis, + transform.node_chunk, + ) + self._spatial_plane = plane + fluence, magnitudes, peaks = ( + np.asarray(part, dtype=np.float64) + for part in call_julia( + self._jl.spatial_local_b, self._engine, grid.dt, conversion + ) + ) + if "peak_intensity" in names: + values["peak_intensity"] = np.asarray(float(np.max(peaks))) + if names & {"beam_radius", "fwhm_r"}: + budget = fluence_budget( + magnitudes, state.shape[1] * grid.n_t + transform.n_modes + ) + widths = signed_fluence_widths(geometry, fluence, budget, axis_fluence) + if "beam_radius" in names: + values["beam_radius"] = np.asarray(widths[:2]) + if "fwhm_r" in names: + values["fwhm_r"] = np.asarray(widths[2]) + return values + def _bind_poynting(self, axis: np.ndarray | None) -> None: """Give the engine the power weight, when it is a new one, and the on-axis rows. From cfa14ce7fda7b3d7193b55f96d62c060fcacfac3 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 00:43:57 +0000 Subject: [PATCH 036/107] Julia: GPU heavy reductions a thread an element, and transforms in batches [skip ci] A heavy reduce_each runs its bodies as an elementwise kernel into scratch and reduces the sums: AK's reduction gave each thread several elements (six blocks for rdw's predictor, 539 us a trial on an A40). A group of transforms over a capillary's few modes goes through one batched plan over a staging buffer on a GPU, one launch for three. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/launch.jl | 40 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index f880da182..d8a2b8743 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -159,6 +159,19 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=fa end return foldl(op, partials; init=neutral) end + if heavy + # A heavy body a thread: AK's reduction gives each thread several elements + # (six blocks for rdw's 10244, its predictor 539 us a trial on an A40), so the + # bodies run as an elementwise kernel into scratch and only the sums reduce. + scratch = KA.allocate(c.backend, typeof(neutral), nt * nm) + each!(c, nt, nm) do t, m + @inbounds scratch[t+(m-1)*nt] = f(t, m) + end + total = AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, + neutral=neutral) + KA.unsafe_free!(scratch) + return total + end AK.mapreduce(op, 1:nt*nm; backend=c.backend, init=neutral, neutral=neutral) do i m = (i - 1) ÷ nt + 1 f(i - (m - 1) * nt, m) @@ -223,7 +236,32 @@ end r = p.ranges[b] mul!(block_view(outs[j], p.batch, r), p.plans[b], block_view(ins[j], p.batch, r)) end -transform_all!(p, outs::Tuple, ins::Tuple) = (foreach((y, x) -> mul!(y, p, x), outs, ins); nothing) +# On a GPU each transform over a capillary's few modes is a few blocks (one a column, +# four for rdw, 96 us each on an A40): the group goes through one batched plan over a +# staging buffer instead, the copies a few microseconds each. +const STAGES = WeakKeyDict{Any,Dict{Int,Any}}() +function transform_all!(p, outs::Tuple, ins::Tuple) + x = first(ins) + if x isa Array + foreach((y, x) -> mul!(y, p, x), outs, ins) + return nothing + end + n, columns = length(ins), size(x, 2) + stage = get!(get!(() -> Dict{Int,Any}(), STAGES, p), n) do + staged = similar(x, size(x, 1), n * columns) + result = similar(first(outs), size(first(outs), 1), n * columns) + (staged, result, eltype(x) <: Real ? plan_rfft(staged, 1) : plan_fft(staged, 1)) + end + staged, result, batched = stage + for j in 1:n + copyto!(view(staged, :, (j-1)*columns+1:j*columns), ins[j]) + end + mul!(result, batched, staged) + for j in 1:n + copyto!(outs[j], view(result, :, (j-1)*columns+1:j*columns)) + end + nothing +end function Base.:*(p::Blocked, x) @batch for b in eachindex(p.plans) p.plans[b] * block_view(x, p.batch, p.ranges[b]) From 6f22b54369a02f4354bacfb6b64bda7eb052e34e Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 00:50:41 +0000 Subject: [PATCH 037/107] Julia: a plasma column's constant head and tail take one fraction each [skip ci] Before the column's support the exposure is exactly zero and past it exactly its last value; each run's fraction is formed once (the same value bit for bit), so only the samples between take an exponential. argon's column pass on one thread 2.85 ms -> 2.59 ms. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/responses.jl | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 64813adb4..bb35f6b02 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -121,15 +121,39 @@ end scratch[i, node] = min(vexp(scratch[i, node]), cap) end end -"""Every sample's fraction and the free current's integrand, vectorised (`vexp`).""" +"""Every sample's fraction and the free current's integrand, vectorised (`vexp`). + +Before the column's support the exposure is exactly zero, and past it exactly its +last value: each run takes the one fraction its exposure gives, formed once, so only +the samples between take an exponential each (the values are the same bit for bit). +""" @noinline function fraction_column!(fraction, integrand, nodes, node, initial, charge, floor) none = zero(initial) - @inbounds @simd for t in axes(nodes, 1) - exposure = floor ? max(fraction[t, node], none) : fraction[t, node] - value = 1 - (1 - initial) * vexp(-exposure) + nt = size(nodes, 1) + fraction_of(exposure) = 1 - (1 - initial) * vexp(-(floor ? max(exposure, none) : exposure)) + head = 0 + @inbounds while head < nt && iszero(fraction[head+1, node]) + head += 1 + end + tail = nt + 1 + @inbounds last = fraction[nt, node] + @inbounds while tail > head + 1 && fraction[tail-1, node] === last + tail -= 1 + end + before, after = fraction_of(none), fraction_of(last) + @inbounds @simd for t in 1:head + fraction[t, node] = before + integrand[t, node] = before * charge * nodes[t, node] + end + @inbounds @simd for t in head+1:tail-1 + value = fraction_of(fraction[t, node]) fraction[t, node] = value integrand[t, node] = value * charge * nodes[t, node] end + @inbounds @simd for t in tail:nt + fraction[t, node] = after + integrand[t, node] = after * charge * nodes[t, node] + end end """The gated and edge currents of a column: the free current plus the loss current, formed everywhere and kept where the rate and the field are live.""" From 70d01bf00f6eb3090a92729a8f39ca1168375487 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 01:00:56 +0000 Subject: [PATCH 038/107] Julia: state-sized copies as the pool's tasks [skip ci] One thread's copy of a Cartesian 192^2 state (226 MB) took 45 ms, and a step made seven (the commit, the split collar, each source, the edge read). pool_copy! runs them as the pool's tasks on a CPU and as one device copy on a GPU, where copy_between! no longer round-trips the host. A Cartesian window on 16 Xeon threads 1.01 s -> 0.78 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/STATUS.md | 1 + julia/src/adams.jl | 10 +++++----- julia/src/dopri.jl | 6 +++--- julia/src/free.jl | 8 ++++---- julia/src/launch.jl | 10 ++++++++++ julia/src/observe.jl | 10 ++++------ 6 files changed, 27 insertions(+), 18 deletions(-) diff --git a/julia/STATUS.md b/julia/STATUS.md index 15245aa46..ec172c1e4 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -46,6 +46,7 @@ Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless | A source's forward transforms, and the quadrature alarm's, as one pool's work | `rdw` on 16 threads: commits 12.3 ms -> 5.8 ms, the source's transforms 8.7 ms -> 3.8 ms | | The exponential Adams march in the engine (`src/march.jl`, native's SEP 39 march transcribed) | `argon_blueshift` on 16 threads 0.42 s -> 0.34 s; the Python march's decisions bit for bit | | Radial and free planes' local statistics in the engine; the plane's admittance kept | radial on 16 threads 0.65 s -> 0.44 s, `line` 0.27 s -> 0.18 s (native's 0.20 s) | +| State-sized copies as the pool's tasks | a Cartesian 192² window on 16 threads 1.01 s -> 0.78 s (native's 0.85 s): one thread's copy of its 226 MB state took 45 ms, and a step made seven | The vectorised functions paid only once the live samples were gathered and each pass was a function of its own: in the column's branchy loop, and inside its closure, LLVM diff --git a/julia/src/adams.jl b/julia/src/adams.jl index 6e34af5b1..d241cdf1a 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -134,9 +134,9 @@ function adams_start!(engine) a = w.adams w.path === nothing || material_stage!(engine, 1) source!(engine, w.y) - copyto!(@view(a.store[:, :, 1]), w.source) + pool_copy!(@view(a.store[:, :, 1]), w.source, c) if a.compensated - copyto!(@view(a.states[:, :, 1]), w.y) + pool_copy!(@view(a.states[:, :, 1]), w.y, c) (; rates) = a linear, phi, weights = c.linear, path_terms(w), a.device.rate each!(c, size(w.y)...) do f, m @@ -272,10 +272,10 @@ end function adams_accept!(engine, slot) w = engine.work a = w.adams - copyto!(@view(a.store[:, :, slot+1]), w.source) + pool_copy!(@view(a.store[:, :, slot+1]), w.source, engine.config) if a.compensated - copyto!(@view(a.states[:, :, slot+1]), w.lab) - copyto!(@view(a.rates[:, :, slot+1]), w.error) + pool_copy!(@view(a.states[:, :, slot+1]), w.lab, engine.config) + pool_copy!(@view(a.rates[:, :, slot+1]), w.error, engine.config) end nothing end diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 8696fa6d5..baf7332ed 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -43,7 +43,7 @@ function trial!(engine, dz::Float64) # c_1 = 0: both propagators are exactly the identity. if !engine.fsal_valid source!(engine, y) - copyto!(@view(stages[:, :, 1]), source) + pool_copy!(@view(stages[:, :, 1]), source, c) end continue end @@ -132,10 +132,10 @@ function commit_step!(engine, dz, monitored) engine.fsal_valid = false elseif !c.low_storage && w.adams === nothing # The last stage's source is the next trial's first. - copyto!(@view(w.stages[:, :, 1]), w.source) + pool_copy!(@view(w.stages[:, :, 1]), w.source, c) engine.fsal_valid = true end - copyto!(w.y, w.candidate) + pool_copy!(w.y, w.candidate, c) c.embedded ? quadrature_alarm(engine) : NaN end diff --git a/julia/src/free.jl b/julia/src/free.jl index c755d7704..9c18d0132 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -142,7 +142,7 @@ function source_free!(engine, lab) (; physical, fine, modal, projected, analytic, loss) = w nm = size(lab, 2) chunk = size(modal, 2) - copyto!(physical, lab) + pool_copy!(physical, lab, c) transverse!(physical, w.spatial_inverse, c) # Transverse inversion first: a transverse spectral column alone is not the # spectrum of a real temporal field. @@ -233,7 +233,7 @@ end function split_free!(engine, dz, monitored) c, w = engine.config, engine.work (; physical, coarse, coarse_spec) = w - copyto!(physical, w.candidate) + pool_copy!(physical, w.candidate, c) transverse!(physical, w.spatial_inverse, c) chunk, nm, nw = size(coarse, 2), size(physical, 2), size(physical, 1) T = real_type(engine) @@ -255,7 +255,7 @@ function split_free!(engine, dz, monitored) end end transverse!(physical, w.spatial_forward, c) - copyto!(w.candidate, physical) + pool_copy!(w.candidate, physical, c) nothing end @@ -263,7 +263,7 @@ function population_free_snapshot(engine, input) c, w = engine.config, engine.work p = w.plasma (; physical, fine, modal, projected) = w - copyto!(physical, scaled_input(engine, input)) + pool_copy!(physical, scaled_input(engine, input), c) transverse!(physical, w.spatial_inverse, c) chunk, nm = size(modal, 2), size(physical, 2) scale = c.field_scale diff --git a/julia/src/launch.jl b/julia/src/launch.jl index d8a2b8743..af20e47bb 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -269,6 +269,16 @@ function Base.:*(p::Blocked, x) x end +"""`copyto!(target, source)` for two state-sized arrays of the device: on a CPU as the +pool's tasks, since one thread's copy of a Cartesian state (226 MB) took 45 ms.""" +function pool_copy!(target, source, c) + oncpu(c) || return copyto!(target, source) + each!(c, size(target)...) do f, m + @inbounds target[f, m] = source[f, m] + end + target +end + """`C = alpha A B + beta C`: on a CPU, blocks of rows of `C` and `A` as the pool's tasks. A complex `C` and `A` against a real `B` are their real views, of twice the rows: one diff --git a/julia/src/observe.jl b/julia/src/observe.jl index def295f3c..2bfb07350 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -19,10 +19,8 @@ On a CPU the pool's tasks copy, each touching its own pages: a single-threaded c of a 226 MB Cartesian state into fresh host memory took 75-220 ms. """ function copy_between!(target, source, c) - if oncpu(c) && eltype(target) == eltype(source) - each!(c, size(target)...) do f, m - @inbounds target[f, m] = source[f, m] - end + if eltype(target) == eltype(source) && (oncpu(c) || !(target isa Array)) + pool_copy!(target, source, c) else copyto!(target, convert(Array{eltype(target)}, Array(source))) end @@ -99,7 +97,7 @@ function monitor_power(engine) end else # The c2r transform overwrites its input: the scratch takes a copy. - copyto!(w.lab, w.y) + pool_copy!(w.lab, w.y, c) mul!(w.coarse, w.coarse_inverse, w.lab) add_power!(power, w.coarse, columns, 1, size(w.y, 2), c) end @@ -186,7 +184,7 @@ function edge_energy(engine) out = edge.energy if c.free physical = w.physical - copyto!(physical, y) + pool_copy!(physical, y, c) transverse!(physical, w.spatial_inverse, c) scale = inv(T(size(y, 2)))^2 colsum!(c, out, size(y)...) do f, m From 07c8224a7556d4b2683947152b371a51e55a1856 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 01:08:47 +0000 Subject: [PATCH 039/107] Julia: a heavy pass splits from a few hundred elements [skip ci] The Adams trial's phi functions cost about 100 ns an element; at the old threshold (2048) argon's 1601 ran serially on 16 threads. argon on 16 Xeon threads: predictor 50 ms -> 5 ms, corrector 22 ms -> 4.6 ms, the window 0.34 s -> 0.29 s. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/launch.jl | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index af20e47bb..c0817ee69 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -74,10 +74,12 @@ end """Split `nt` x `nm` samples into column pieces: one task's worth each. A `heavy` body (tens of operations a sample, such as the phi functions) is worth -splitting at a thirty-second of the samples a light one needs. +splitting from a few hundred samples. """ function tiling(tasks, nt, nm, heavy=false) - least = heavy ? PARALLEL_SAMPLES ÷ 32 : PARALLEL_SAMPLES + # A heavy body (the Adams trial's phi functions, about 100 ns an element) pays for a + # task from a few hundred elements: argon's 1601 ran serially on 16 threads. + least = heavy ? 256 : PARALLEL_SAMPLES if tasks == 1 || nt * nm < least return 1, nt end From 4b5bcd4cd7928220d47f07e354355da48032e7af Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 01:20:05 +0000 Subject: [PATCH 040/107] Julia: products with a thin side as a loop over the pool, not BLAS [skip ci] A capillary's one mode made each projection sixteen BLAS calls of one column apiece, whose overheads were most of the time: products with at most eight columns or inner terms run as blocked axpys over the pool. argon's plasma projections on 16 Xeon threads 54 ms -> 22 ms. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/launch.jl | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index c0817ee69..403db70e7 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -292,6 +292,9 @@ function gemm!(C, A, B, alpha, beta, c) if eltype(C) <: Complex && eltype(A) <: Complex && eltype(B) <: Real return gemm!(real_rows(C), real_rows(A), B, alpha, beta, c) end + if oncpu(c) && eltype(C) <: Real && (size(B, 2) <= THIN || size(B, 1) <= THIN) + return thin_gemm!(C, A, B, alpha, beta, c) + end blocks = oncpu(c) ? min(c.tasks, cld(length(C), PARALLEL_SAMPLES ÷ 4)) : 1 blocks <= 1 && return mul!(C, A, B, alpha, beta) rows = cld(size(C, 1), blocks) @@ -302,6 +305,42 @@ function gemm!(C, A, B, alpha, beta, c) C end +"""A product's thin side, at most this many columns or inner terms: a loop, not BLAS.""" +const THIN = 8 + +"""`C = alpha A B + beta C` for real matrices with a thin `B`: as the pool's tasks over +blocks of rows, each a column of `C` at a time, a contiguous axpy per inner term. +A capillary's one mode made each projection sixteen BLAS calls of a vector each, +whose overheads were most of argon's 0.25 ms a source.""" +function thin_gemm!(C, A, B, alpha, beta, c) + rows, inner = size(A) + columns = size(B, 2) + blocks = max(1, min(c.tasks, cld(rows * (inner + columns), PARALLEL_SAMPLES ÷ 4))) + span = cld(rows, blocks) + a, b = eltype(C)(alpha), eltype(C)(beta) + @batch for block in 1:blocks + r = (block-1)*span+1:min(block * span, rows) + @inbounds for j in 1:columns + if iszero(b) + @simd for t in r + C[t, j] = 0 + end + elseif !isone(b) + @simd for t in r + C[t, j] *= b + end + end + for p in 1:inner + weight = a * B[p, j] + @simd for t in r + C[t, j] += A[t, p] * weight + end + end + end + end + C +end + """A column-contiguous complex matrix as the real one of its interleaved parts.""" real_rows(X) = reshape(reinterpret(real(eltype(X)), X), 2size(X, 1), size(X, 2)) From 196baa5159577ab72f1f84c519ae58efd590826a Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 01:31:05 +0000 Subject: [PATCH 041/107] Julia: the runtime loads the named GPU's package, AMDGPU for rocm [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- src/solprop/backends/julia/_runtime.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/solprop/backends/julia/_runtime.py b/src/solprop/backends/julia/_runtime.py index c2c43eab9..c27b29664 100644 --- a/src/solprop/backends/julia/_runtime.py +++ b/src/solprop/backends/julia/_runtime.py @@ -75,6 +75,10 @@ def call_julia(function: Any, *args: object, nogil: bool = False) -> Any: # JuliaCall exposes dynamically compiled Julia modules, so Any is confined to its # boundary. Numerical arrays are converted to owned NumPy arrays by the adapter. +_GPU_PACKAGES = {"cuda": "CUDA", "rocm": "AMDGPU"} +"""Each GPU device's Julia package, loaded before the engine.""" + + @functools.cache def runtime() -> Any: """Load the experimental Julia module from this source checkout. @@ -138,8 +142,9 @@ def runtime() -> Any: import juliacall # noqa: PLC0415 - Julia must never initialize on package import module = juliacall.newmodule("SolpropBackend") - if device == "cuda": - call_julia(module.seval, "using CUDA") + if device != "cpu": + # The GPU package first, so that SolpropJulia loads with its extension. + call_julia(module.seval, f"using {_GPU_PACKAGES[device]}") digest = source_digest() call_julia(module.seval, "using SolpropJulia") module.SolpropJulia.record_digest(digest) From 8a6d184e8a4c10fab5dc2687358b920176d22df4 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 01:39:27 +0000 Subject: [PATCH 042/107] Julia: the collar's half-step factor once a sample, not once an element [skip ci] The split's factor exp(-dz rate[t] / 2) / n depends on the sample alone; each mode formed it again (331k exponentials a radial commit for 864 values). The same product bit for bit. Radial commits on 16 Xeon threads 31 ms -> 17 ms a window. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/dopri.jl | 13 ++++++++++++- julia/src/free.jl | 3 ++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index baf7332ed..5d3bd80eb 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -151,12 +151,23 @@ function split_modal!(engine, dz, monitored) T = real_type(engine) # The unnormalised inverse's 1/nc is folded into the collar's factor. half, inverse = T(-0.5 * dz), inv(T(c.nc)) + factor = collar_factor(rate, half, inverse, c) each!(c, size(coarse)...) do t, m - @inbounds coarse[t, m] *= exp(half * rate[t]) * inverse + @inbounds coarse[t, m] *= factor[t] end mul!(w.candidate, w.coarse_forward, coarse) end +"""The collar's half-step factor a sample, `exp(half rate[t]) inverse`, formed once a +sample rather than once an element (384 modes each took the same exponential).""" +function collar_factor(rate, half, inverse, c) + factor = similar(rate) + each!(c, length(rate), 1) do t, _ + @inbounds factor[t] = exp(half * rate[t]) * inverse + end + factor +end + """The embedded coarse quadrature's relative defect in the last stage's source.""" function quadrature_alarm(engine) c, w = engine.config, engine.work diff --git a/julia/src/free.jl b/julia/src/free.jl index 9c18d0132..7ec89e043 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -241,13 +241,14 @@ function split_free!(engine, dz, monitored) # Both unnormalised inverses' 1/(nc n_x n_y) is folded into the collar's factor. inverse = inv(T(c.nc) * T(nm)) monitored && fill!(w.monitor.split, 0) + factor = collar_factor(rate, half, inverse, c) for first in 1:chunk:nm count = min(chunk, nm - first + 1) columns_into!(coarse_spec, physical, first, count, c) mul!(coarse, w.coarse_inverse, coarse_spec) monitored && add_power!(w.monitor.split, coarse, w.monitor.columns, first, count, c) each!(c, size(coarse)...) do t, m - @inbounds coarse[t, m] *= exp(half * rate[t]) * inverse + @inbounds coarse[t, m] *= factor[t] end mul!(coarse_spec, w.coarse_forward, coarse) each!(c, nw, count) do f, m From d4ca1822d9ef20b24a2cfa4db9e50c5ee9917429 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 01:44:16 +0000 Subject: [PATCH 043/107] Julia: a GPU integral's filter and trapezoid increments in one kernel [skip ci] Each increment filters its two samples itself: the values of a filtered pass and an increments pass, with one kernel and one memory pass fewer, two a plasma evaluation. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/responses.jl | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index bb35f6b02..db019f7f0 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -304,14 +304,14 @@ plasma_current!(p, nodes, c, count) = const SAMPLE_PLASMA = Ref(false) """`out` = the running trapezoid of the FIR-filtered `values`, every column at once.""" -function integrate_samples!(out, values, scratch, taps, dt, c, count) +function integrate_samples!(out, values, taps, dt, c, count) nt = size(values, 1) + half, none = dt / 2, zero(dt) + # Each trapezoid increment filters its two samples itself: the same values as a + # filtered pass and then an increments pass, one kernel and one memory pass fewer. each!(c, nt, count) do t, n - @inbounds scratch[t, n] = filtered(values, t, n, taps) - end - half = dt / 2 - each!(c, nt, count) do t, n - @inbounds out[t, n] = t == 1 ? zero(dt) : half * (scratch[t, n] + scratch[t-1, n]) + @inbounds out[t, n] = t == 1 ? none : + half * (filtered(values, t, n, taps) + filtered(values, t - 1, n, taps)) end AK.accumulate!(+, @view(out[:, 1:count]); dims=1, init=zero(dt), backend=c.backend) nothing @@ -328,7 +328,7 @@ function plasma_samples!(p, nodes, c, count) each!(c, nt, count) do t, n @inbounds rate[t, n] = scaled_rate(nodes[t, n], args...) end - integrate_samples!(fraction, rate, current, taps, dt, c, count) + integrate_samples!(fraction, rate, taps, dt, c, count) each!(c, nt, count) do t, n @inbounds begin exposure = floor ? max(fraction[t, n], none) : fraction[t, n] @@ -337,7 +337,7 @@ function plasma_samples!(p, nodes, c, count) integrand[t, n] = value * charge * nodes[t, n] end end - integrate_samples!(current, integrand, gated, taps, dt, c, count) + integrate_samples!(current, integrand, taps, dt, c, count) each!(c, nt, count) do t, n @inbounds begin field = nodes[t, n] @@ -429,7 +429,7 @@ function population_samples!(p, nodes, c, first, count) each!(c, nt, count) do t, n @inbounds rate[t, n] = scaled_rate(nodes[t, n], args...) end - integrate_samples!(fraction, rate, current, taps, dt, c, count) + integrate_samples!(fraction, rate, taps, dt, c, count) columns = 1:count # The exposure's steps, then its fractions, the depletion they pay and the integrand. each!(c, nt, count) do t, n From 231dc9ae91bd46b80a4e1020fb9e4ac069de0741 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 01:56:56 +0000 Subject: [PATCH 044/107] Julia: a varying guide's power weight rebound alone, compiled at construction [skip ci] rdw's weight is formed again at each plane; each bound the Poynting buffers again through a call whose signature (without the on-axis rows) the warm-up had not compiled: 37 ms of 12 planes. rebind_weight! takes the weight alone and is warmed with the rest. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/observe.jl | 10 +++++++++- src/solprop/backends/julia/_backend.py | 22 ++++++++++++++++------ 2 files changed, 25 insertions(+), 7 deletions(-) diff --git a/julia/src/observe.jl b/julia/src/observe.jl index 2bfb07350..d3d8b51e0 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -226,7 +226,14 @@ function bind_poynting!(engine, weight, axis) host_power=zeros(T, nt, nm), host_flux=zeros(T, rows === nothing ? 0 : nt)) w.statistics[] = s end - copyto!(s.weight, T.(Matrix{Float64}(weight))) + rebind_weight!(engine, weight) +end + +"""A new power weight (n_omega, n_modes) for the bound Poynting buffers: a varying +guide's, at each plane.""" +function rebind_weight!(engine, weight) + target = engine.work.statistics[].weight + copyto!(target, eltype(target).(Matrix{Float64}(weight))) nothing end @@ -286,6 +293,7 @@ function poynting!(engine, flux) end const bind_poynting_b = bind_poynting! +const rebind_weight_b = rebind_weight! const poynting_b = poynting! # --- the spatial routes' local statistics -------------------------------------------- diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 8fde158e2..f31be455a 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -563,6 +563,12 @@ def _warm_bridge(self) -> None: # The Poynting transforms' plan is measured here, not at the first plane. axis = None if self._modes is None else self._on_axis_synthesis(self._modes) self._bind_poynting(axis) + # A varying guide's weight is bound again at each plane: compiled here too. + call_julia( + jl.rebind_weight_b, + engine, + np.ascontiguousarray(self._weight[:, 0, :].T), + ) for flux in (False, axis is not None): np.asarray(call_julia(jl.poynting_b, engine, flux)[0]) call_julia(jl.bind_monitor_b, engine, None, None) @@ -1244,12 +1250,16 @@ def _bind_poynting(self, axis: np.ndarray | None) -> None: """ if self._poynting_weight is self._weight: return - call_julia( - self._jl.bind_poynting_b, - self._engine, - np.ascontiguousarray(self._weight[:, 0, :].T), - None if axis is None else np.ascontiguousarray(axis), - ) + weight = np.ascontiguousarray(self._weight[:, 0, :].T) + if self._poynting_weight is None: + call_julia( + self._jl.bind_poynting_b, + self._engine, + weight, + None if axis is None else np.ascontiguousarray(axis), + ) + else: + call_julia(self._jl.rebind_weight_b, self._engine, weight) self._poynting_weight = self._weight def _populations(self, spec: StatsSpec, state: np.ndarray) -> dict[str, np.ndarray]: From 50158fa68d33cfacaedefaa1a38a101d868bd18d Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 02:16:16 +0000 Subject: [PATCH 045/107] Julia: GPU column and row sums, local sums and occupancy by device reductions [skip ci] A thread a column or a row left most of a GPU idle (radial's local sums 360 us, the monitor's row sums 99 us, the column sums 129 us a call on an AMD Instinct MI325X), and the occupancy's atomics on a crossing's few buckets contended (747 us). Their terms now fill a scratch matrix in parallel for the device's own reductions, and the histogram is formed a workgroup at a time in local memory. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/launch.jl | 25 ++++++++---- julia/src/observe.jl | 90 +++++++++++++++++++++++++++++++++++--------- 2 files changed, 90 insertions(+), 25 deletions(-) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 403db70e7..5b15a4d80 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -97,6 +97,16 @@ function each_on!(f::F, backend, tasks, nt, nm, heavy) where {F} nothing end +"""`f(t, m)` at every sample, into a device scratch matrix of `out`'s element type, for +a device reduction over its rows or columns.""" +function reduce_terms(f::F, c, out, nt, nm) where {F} + scratch = KA.allocate(c.backend, eltype(out), nt, nm) + each!(c, nt, nm) do t, m + @inbounds scratch[t, m] = f(t, m) + end + scratch +end + """Call `f(m)` for each of `nm` columns, whose body runs sequentially down one.""" function each_column!(f::F, c, nm::Integer) where {F} CHECK[] && check_body(F) @@ -128,13 +138,14 @@ function rowsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} end end else - AK.foreachindex(1:nt; backend=c.backend) do t - total = zero(eltype(out)) - for m in 1:nm - total += f(t, m) - end - @inbounds out[t] += total - end + # A thread a row looped over every column (36864 for a Cartesian plane): the + # terms fill a scratch matrix in parallel and the device's reduction sums it. + scratch = reduce_terms(f, c, out, nt, nm) + total = KA.allocate(c.backend, eltype(out), nt, 1) + sum!(total, scratch) + out .+= vec(total) + KA.unsafe_free!(scratch) + KA.unsafe_free!(total) end nothing end diff --git a/julia/src/observe.jl b/julia/src/observe.jl index d3d8b51e0..261ad7373 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -112,6 +112,34 @@ function columns_into!(target, source, first, count, c) end """The state's spectral energy in each of the split crossing's rate buckets.""" +# A device's histogram a workgroup at a time in local memory, then added: every sample's +# atomic add on the few global buckets a crossing uses contended (747 us a radial +# occupancy on an AMD Instinct MI325X). +KA.@kernel function bucket_kernel!(histogram, @Const(y), @Const(buckets), @Const(columns), nw, n) + i = KA.@index(Global, Linear) + local_index = KA.@index(Local, Linear) + groupsize = KA.@groupsize()[1] + shared = KA.@localmem eltype(histogram) (128,) + b = local_index + while b <= 128 + @inbounds shared[b] = 0 + b += groupsize + end + KA.@synchronize + if i <= n + m = (i - 1) ÷ nw + 1 + f = i - (m - 1) * nw + @inbounds Atomix.@atomic shared[buckets[f, m]] += abs2(y[f, m]) * columns[m] + end + KA.@synchronize + b = local_index + while b <= 128 + @inbounds value = shared[b] + !iszero(value) && (@inbounds Atomix.@atomic histogram[b] += value) + b += groupsize + end +end + function occupancy(engine) c, w = engine.config, engine.work (; buckets, columns, histogram) = w.monitor @@ -127,11 +155,8 @@ function occupancy(engine) end end else - AK.foreachindex(1:nw*nm; backend=c.backend) do i - m = (i - 1) ÷ nw + 1 - f = i - (m - 1) * nw - @inbounds Atomix.@atomic histogram[buckets[f, m], 1] += abs2(y[f, m]) * columns[m] - end + bucket_kernel!(c.backend, 256)(view(histogram, :, 1), y, buckets, columns, nw, + nw * nm; ndrange=nw * nm) end vec(sum(Array{Float64}(Array(histogram)); dims=2)) .* engine.config.scale^2 end @@ -140,6 +165,13 @@ end """Set `out[m]` to the sum over `t` of `f(t, m)`: one column's reduction each.""" function colsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} + if !oncpu(c) + # A thread a column left most of the device idle: a parallel fill and a sum. + scratch = reduce_terms(f, c, out, nt, nm) + sum!(reshape(out, 1, :), scratch) + KA.unsafe_free!(scratch) + return nothing + end each_column!(c, nm) do m total = zero(eltype(out)) @inbounds for t in 1:nt @@ -375,21 +407,43 @@ function spatial_local!(engine, dt, conversion) end s.inverse * target end - each_column!(c, count) do n - total, magnitude, peak = start, start, lowest - @inbounds for t in 1:nt - e, h = signal[t, n], other[t, n] - intensity = flux * real(e * conj(h)) * factor - total += intensity - magnitude += abs(e) * abs(h) * factor - peak = max(peak, intensity) + if oncpu(c) + each_column!(c, count) do n + total, magnitude, peak = start, start, lowest + @inbounds for t in 1:nt + e, h = signal[t, n], other[t, n] + intensity = flux * real(e * conj(h)) * factor + total += intensity + magnitude += abs(e) * abs(h) * factor + peak = max(peak, intensity) + end + @inbounds begin + fluence[first+n-1] = step * total + magnitudes[first+n-1] = flux * step * magnitude + peaks[first+n-1] = peak + end + nothing end - @inbounds begin - fluence[first+n-1] = step * total - magnitudes[first+n-1] = flux * step * magnitude - peaks[first+n-1] = peak + else + # A device's reductions over a parallel fill, not a thread a node. + fluxes = reduce_terms(c, fluence, nt, width) do t, n + @inbounds flux * real(signal[t, n] * conj(other[t, n])) * factor + end + products = reduce_terms(c, fluence, nt, width) do t, n + @inbounds abs(signal[t, n]) * abs(other[t, n]) * factor + end + totals, sizes, highest = (KA.allocate(c.backend, T, 1, width) for _ in 1:3) + sum!(totals, fluxes) + sum!(sizes, products) + maximum!(highest, fluxes) + each!(c, count, 1) do n, _ + @inbounds begin + fluence[first+n-1] = step * totals[1, n] + magnitudes[first+n-1] = flux * step * sizes[1, n] + peaks[first+n-1] = highest[1, n] + end end - nothing + foreach(KA.unsafe_free!, (fluxes, products, totals, sizes, highest)) end end (Vector{Float64}(Array(fluence)), Vector{Float64}(Array(magnitudes)), From daef3385540d81659bb4cc27ad0bf9197c431f5e Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 03:30:50 +0000 Subject: [PATCH 046/107] Julia: a GPU's transform staging held in the engine's workspace, not a global table [skip ci] The staging buffers and batched plan were kept in a global WeakKeyDict of plans; they now live in the workspace (forward_stage) with the plans they serve. One binary32 A40 window hung until the worker's timeout after the global table arrived; the cause is not established. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/dopri.jl | 2 +- julia/src/launch.jl | 16 ++++++++++------ julia/src/modal.jl | 5 +++-- 3 files changed, 14 insertions(+), 9 deletions(-) diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 5d3bd80eb..6f2762e5d 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -177,7 +177,7 @@ function quadrature_alarm(engine) else p = w.plasma transform_all!(w.forward_plan, (w.coarse_spec, p.spectrum, p.edge_spectrum), - (w.projected_coarse, p.coarse, p.coarse_edge)) + (w.projected_coarse, p.coarse, p.coarse_edge), w.forward_stage) add_plasma_spectra!(w.coarse_spec, p, c) end (; prefactor, omega_window, crop) = c diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 5b15a4d80..d28e6ad34 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -251,21 +251,23 @@ end end # On a GPU each transform over a capillary's few modes is a few blocks (one a column, # four for rdw, 96 us each on an A40): the group goes through one batched plan over a -# staging buffer instead, the copies a few microseconds each. -const STAGES = WeakKeyDict{Any,Dict{Int,Any}}() -function transform_all!(p, outs::Tuple, ins::Tuple) +# staging buffer instead, the copies a few microseconds each. The staging lives in the +# engine's workspace (`stage`, a `Ref`), not in a global table of plans. +function transform_all!(p, outs::Tuple, ins::Tuple, stage::Ref) x = first(ins) if x isa Array foreach((y, x) -> mul!(y, p, x), outs, ins) return nothing end n, columns = length(ins), size(x, 2) - stage = get!(get!(() -> Dict{Int,Any}(), STAGES, p), n) do + held = stage[] + if held === nothing || size(held[1], 2) != n * columns staged = similar(x, size(x, 1), n * columns) result = similar(first(outs), size(first(outs), 1), n * columns) - (staged, result, eltype(x) <: Real ? plan_rfft(staged, 1) : plan_fft(staged, 1)) + held = (staged, result, eltype(x) <: Real ? plan_rfft(staged, 1) : plan_fft(staged, 1)) + stage[] = held end - staged, result, batched = stage + staged, result, batched = held for j in 1:n copyto!(view(staged, :, (j-1)*columns+1:j*columns), ins[j]) end @@ -275,6 +277,8 @@ function transform_all!(p, outs::Tuple, ins::Tuple) end nothing end +transform_all!(p::Blocked, outs::Tuple, ins::Tuple, ::Ref) = transform_all!(p, outs, ins) + function Base.:*(p::Blocked, x) @batch for b in eachindex(p.plans) p.plans[b] * block_view(x, p.batch, p.ranges[b]) diff --git a/julia/src/modal.jl b/julia/src/modal.jl index eb67c775b..c22d2ec60 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -76,7 +76,7 @@ function create_modal(c, host) node_forward=spectral ? plan(c, plan_rfft, nodes, 1) : nothing, absorber_spec_band=dzeros(c, C, spectral && in_stage ? nw : 0, spectral && in_stage ? nm : 0), adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), - monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), statistics=Ref{Any}(nothing), + monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), forward_stage=Ref{Any}(nothing), statistics=Ref{Any}(nothing), raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), @@ -142,7 +142,8 @@ function source!(engine, lab; quadrature=false) # The source's and the currents' transforms as one pool's work. p = w.plasma @section :forward_fft transform_all!(w.forward_plan, (w.fine, p.spectrum, p.edge_spectrum), - (w.projected, p.projected, p.edge_projected)) + (w.projected, p.projected, p.edge_projected), + w.forward_stage) @section :plasma_spectrum add_plasma_spectra!(w.fine, p, c) end if c.in_stage From 48809a8dfec459a05c4568820b37bcc6d4f8de6c Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 03:30:50 +0000 Subject: [PATCH 047/107] Julia: the latest CPU, A40 and MI325X rows in the ledger and STATUS [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- docs/dev/benchmarks.md | 57 ++++++++++++++++++++++++++++++++++++++++++ julia/STATUS.md | 45 +++++++++++++++++++-------------- 2 files changed, 83 insertions(+), 19 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index aa5e0aaf5..eabae8287 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -2937,6 +2937,24 @@ before the vectorised plasma and the batched transforms, the same plan gave 1.64 next commit, `207add18`, runs the Adams march in the engine: `argon_blueshift` on 16 threads 0.42 s -> 0.34 s and `rdw` 0.157 -> 0.148 s (single profiled runs, socket 0). +Later, the same plan at commit `50158fa6` (the Julia march, the spatial statistics, the +pooled copies, the thin products and the rest of the CPU changes), three rounds, the +machine quiet at the start and at load 11 to 14 by the end: + +| case | native 1 thread, s | julia | ratio | native 16 threads, s | julia | ratio | +|---|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.418 | 0.681 | 1.54 | 0.189 | 0.216 | 1.14 | +| `argon_blueshift` | 0.545 | 0.961 | 1.77 | 0.186 | 0.249 | 1.30 | +| `h2_raman_6ps` | 3.385 | 4.254 | 1.25 | 2.871 | 1.743 | 0.86 | +| `ctc_reduced` | 1.012 | 1.871 | 1.85 | 0.377 | 0.381 | 1.01 | +| `radial_filament_256` | 2.163 | 2.222 | 1.02 | 0.368 | 0.564 | 1.52 | +| `kerr_beam_192` | 5.147 | 5.824 | 1.12 | 0.996 | 1.119 | 1.11 | +| `line` | 0.679 | 0.821 | 1.20 | 0.185 | 0.212 | 1.17 | + +Geometric mean 1.25 (1.42 at `7c7ac9b7`). The load spread some rounds widely +(`h2_raman_6ps` 0.59 to 0.88 and `kerr_beam_192` 0.67 to 1.35 on 16 threads); the +ratios are medians of paired rounds, both arms under the same load. + **NVIDIA A40** (driver 595.71), native's CUDA build (AMPERE86) against `julia` with `SOLPROP_JULIA_DEVICE=cuda` (CUDA.jl 6.5), `--device`, two rounds, commit `7c7ac9b7`: @@ -2958,3 +2976,42 @@ Systems (`rdw`, commit `7c7ac9b7`): the device is busy for about 124 ms of the 0 window. Nine transforms a source at 96 us each (over four modes, so a few blocks each: latency, not work) are a third; the Adams predictor's reduction, heavy binary64 work a sample on too few threads, 539 us a trial; then the plasma and Kerr passes. + +At commit `cfa14ce7` (the Julia march; the GPU's heavy reductions a thread an element and +its transforms in batches) the same plan gave, binary64 then binary32: + +| case | native, s | julia binary64, s | ratio | julia binary32, s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.054 | 0.137 | 2.53 | 0.182 | 3.27 | +| `argon_blueshift` | 0.117 | 0.338 | 2.89 | 0.280 | 2.39 | +| `h2_raman_6ps` | 1.040 | 1.180 | 1.14 | 0.674 | 0.65 | +| `ctc_reduced` | 0.207 | 0.323 | 1.56 | 0.317 | 1.53 | +| `radial_filament_256` | 0.173 | 0.513 | 2.97 | 0.408 | 2.37 | +| `kerr_beam_192` | 0.198 | 0.648 | 3.28 | 0.673 | 3.52 | +| `line` | 0.095 | 0.271 | 2.84 | 0.213 | 2.20 | + +Geometric means 2.32 and 2.03. One binary32 `argon_blueshift` round hung until the +worker's timeout (the other ran at 2.39); `rdw`'s binary64 field differed from native's +by 1.8e-11, the reordered reduction of the Adams norms, with the same steps. + +**AMD Instinct MI325X** (a rented droplet, ROCm 10.0), native's HIP build (gfx942) +against `julia` with `SOLPROP_JULIA_DEVICE=rocm` (AMDGPU.jl 2.11), `--device`, two +rounds, commit `196baa51`. The first run of the AMDGPU extension: the device tests +pass (binary64 against `numpy_ref` to 1e-10, binary32 to 1e-4), and every binary64 row +took native's steps with its fields to rounding. + +| case | native, s | julia binary64, s | ratio | julia binary32, s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.027 | 0.055 | 2.03 | 0.088 | 3.27 | +| `argon_blueshift` | 0.057 | 0.134 | 2.33 | 0.124 | 2.16 | +| `h2_raman_6ps` | 0.231 | 0.395 | 1.71 | 0.364 | 1.57 | +| `ctc_reduced` | 0.061 | 0.138 | 2.27 | 0.129 | 2.09 | +| `radial_filament_256` | 0.046 | 0.224 | 4.85 | 0.188 | 3.99 | +| `kerr_beam_192` | 0.076 | 0.260 | 3.44 | 0.347 | 4.50 | +| `line` | 0.056 | 0.106 | 1.89 | 0.112 | 2.04 | + +Geometric means 2.48 (binary64) and 2.62 (binary32 against native's binary64). A +`rocprofv3` trace of the radial window found the column-at-a-thread passes (the local +statistics' sums, the monitor's row and column sums) and the occupancy's atomics on a +crossing's few buckets the largest kernels; commit `50158fa6` forms them as device +reductions. diff --git a/julia/STATUS.md b/julia/STATUS.md index ec172c1e4..62af7c8e9 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -17,8 +17,8 @@ to current main and rewrites the engine: the driver's bundle cache, the general-leaf and carrier-frame refusals, SEP 21's split collar and SEP 44's transverse edge read through the engine. - **One source for CPU and GPU, binary64 and binary32.** Every state-sized operation is a - scalar body run by the device layer (`src/launch.jl`); arrays are `Array`s or - `CuArray`s (the CUDA package extension) of `Float64` or `Float32`. The kernel bodies + scalar body run by the device layer (`src/launch.jl`); arrays are `Array`s, `CuArray`s + or `ROCArray`s (the CUDA and AMDGPU package extensions) of `Float64` or `Float32`. The kernel bodies capture only values and arrays, which `SOLPROP_JULIA_CHECK` enforces on a CPU. - **Julia 1.13.3**, CUDA.jl 6.5, FFTW.jl, Polyester, KernelAbstractions and AcceleratedKernels; numba is gone from the tooling, which is now solprop's own harness. @@ -47,6 +47,12 @@ Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless | The exponential Adams march in the engine (`src/march.jl`, native's SEP 39 march transcribed) | `argon_blueshift` on 16 threads 0.42 s -> 0.34 s; the Python march's decisions bit for bit | | Radial and free planes' local statistics in the engine; the plane's admittance kept | radial on 16 threads 0.65 s -> 0.44 s, `line` 0.27 s -> 0.18 s (native's 0.20 s) | | State-sized copies as the pool's tasks | a Cartesian 192² window on 16 threads 1.01 s -> 0.78 s (native's 0.85 s): one thread's copy of its 226 MB state took 45 ms, and a step made seven | +| A heavy pass splits from a few hundred elements | `argon_blueshift`'s Adams predictor on 16 threads 50 ms -> 5 ms (its 1601 elements ran serially) | +| Products with a thin side (at most eight columns or terms) as blocked loops, not BLAS | `argon_blueshift`'s plasma projections on 16 threads 54 ms -> 22 ms | +| The collar's half-step factor once a sample, not once an element | radial commits on 16 threads 31 ms -> 17 ms | +| A varying guide's power weight rebound alone, warmed at construction | `rdw`'s 12 planes 37 ms of binding -> none | +| GPU: heavy reductions a thread an element; batched transforms; one kernel a trapezoid increment | the A40's binary64 geometric mean 2.77 -> 2.32 | +| GPU: column and row sums, local sums and occupancy by device reductions | (from the MI325X's trace; measured in the ledger) | The vectorised functions paid only once the live samples were gathered and each pass was a function of its own: in the column's branchy loop, and inside its closure, LLVM @@ -56,23 +62,24 @@ rate is a vectorised `log`, the lookup and a vectorised `exp`, three passes. ## Where it stands Julia's window time over native's, 2 % of each case, both arms in one interpreter, the -same steps and fields equal to rounding (1e-13 or better); the ledger has the seconds. - -| case | Xeon, 1 thread | Xeon, 16 threads | A40, binary64 | A40, binary32 | -|---|---:|---:|---:|---:| -| rdw | 1.41 | 1.03 | 3.13 | 3.38 | -| argon_blueshift | 2.41 | 1.79 | 3.85 | 2.72 | -| h2_raman_6ps | 1.02 | 1.13 | 1.26 | 0.96 | -| ctc_reduced | 1.75 | 1.01 | 1.87 | 1.71 | -| radial_filament_256 | 1.08 | 2.14 | 3.73 | 3.24 | -| kerr_beam_192 | 1.14 | 1.67 | 3.58 | 3.50 | -| line | 1.30 | 1.78 | 3.30 | 3.12 | - -Intel Xeon Gold 6240 (16 cores of socket 1, a shared machine) and NVIDIA A40 against -native's CUDA build, both at commit `7c7ac9b7`; geometric means 1.42, 2.77 and 2.45. The -next commit's Julia march takes `argon_blueshift` on 16 threads from 0.42 s to 0.34 s. -Binary32 is against native's binary64. Ratios measured before the harness fix (#557) -counted 0.18 s of metadata on both arms and are not comparable. +same steps and binary64 fields equal to rounding (1e-13 or better); the ledger has the +seconds, the machines and the earlier rows. + +| case | Xeon, 1 thread | Xeon, 16 threads | A40, binary64 | A40, binary32 | MI325X, binary64 | +|---|---:|---:|---:|---:|---:| +| rdw | 1.54 | 1.14 | 2.53 | 3.27 | 2.03 | +| argon_blueshift | 1.77 | 1.30 | 2.89 | 2.39 | 2.33 | +| h2_raman_6ps | 1.25 | 0.86 | 1.14 | 0.65 | 1.71 | +| ctc_reduced | 1.85 | 1.01 | 1.56 | 1.53 | 2.27 | +| radial_filament_256 | 1.02 | 1.52 | 2.97 | 2.37 | 4.85 | +| kerr_beam_192 | 1.12 | 1.11 | 3.28 | 3.52 | 3.44 | +| line | 1.20 | 1.17 | 2.84 | 2.20 | 1.89 | + +Intel Xeon Gold 6240 (16 cores of socket 1, a shared machine) at commit `50158fa6`, +geometric mean 1.25; NVIDIA A40 against native's CUDA build at `cfa14ce7`, 2.32 and +2.03; AMD Instinct MI325X against native's HIP build at `196baa51`, 2.48, before the +GPU's column reductions. Binary32 is against native's binary64. Ratios measured before +the harness fix (#557) counted 0.18 s of metadata on both arms and are not comparable. ## What is left, measured From 6826fcd6d63acb83e069129fa5d737d5e4d0d9dc Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 03:51:38 +0000 Subject: [PATCH 048/107] Julia: a plasma integral's interior FIR in one pass [skip ci] Each interior sample's sum is formed in the order the taps give it (the centre, then each pair), as the tap-at-a-time passes formed it, bit for bit, in one pass with the taps a tuple: a fifth of the memory traffic. ctc_reduced's integral on one Xeon thread 0.50 ms -> 0.27 ms, its plasma column pass 4.7-6.3 ms -> 3.8-3.9 ms (a loaded machine). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/responses.jl | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index db019f7f0..49c201f75 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -197,6 +197,20 @@ end value end +"""The interior samples' FIR, one pass: each sample's sum in the order the taps give it +(the centre, then each pair), as the tap-at-a-time passes formed it, bit for bit, with +a fifth of their memory traffic. The taps are a tuple, so the sum unrolls and the +samples vectorise.""" +@noinline function fir_interior!(out, values, node, first, last, taps::NTuple{N}) where {N} + @inbounds @simd for t in first:last + value = taps[1] * values[t, node] + for k in 1:N-1 + value += taps[k+1] * (values[t-k, node] + values[t+k, node]) + end + out[t, node] = value + end +end + """Integrate one column of `values` into `out`, sequentially down the column. Exact zero support is skipped: reflection cannot carry the live interval past the @@ -225,19 +239,13 @@ any one sample's additions. out[t, node] = 0 end interior_first, interior_last = max(first, half + 1), min(last, nt - half) - @inbounds for t in first:last - if t < interior_first || t > interior_last - out[t, node] = filtered(values, t, node, taps) - else - out[t, node] = taps[1] * values[t, node] - end + @inbounds for t in first:interior_first-1 + out[t, node] = filtered(values, t, node, taps) end - @inbounds for k in 1:half - tap = taps[k+1] - @simd for t in interior_first:interior_last - out[t, node] += tap * (values[t-k, node] + values[t+k, node]) - end + @inbounds for t in interior_last+1:last + out[t, node] = filtered(values, t, node, taps) end + fir_interior!(out, values, node, interior_first, interior_last, Tuple(taps)) @inbounds previous = out[1, node] total = zero(dt) @inbounds out[1, node] = 0 From a8221ef36dc7507aeb4a384e06ec9ea95929a099 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 04:03:54 +0000 Subject: [PATCH 049/107] Julia: the live rates' knot and offset in the vectorised pass [skip ci] The table's index and the distance past its knot are formed with the logarithm in the vectorised pass; only the four loads and the cubic stay scalar, with log_rate's values bit for bit. ctc_reduced's live rates on one Xeon thread 9.1 ns -> 8.1 ns a sample. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/responses.jl | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 49c201f75..a4f0cb760 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -90,6 +90,7 @@ function plasma_workspace(c, host, nt, chunk, nm, nn) # A CPU column's live samples, by index, and their fields (`exposure_column!`). live=zeros(Int32, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), scratch=zeros(T, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), + knots=zeros(Int32, oncpu(c) ? nt : 0, oncpu(c) ? chunk : 0), integrand=dzeros(c, T, nt, chunk), current=dzeros(c, T, nt, chunk), gated=dzeros(c, T, nt, chunk), edge=dzeros(c, T, nt, chunk), projected=dzeros(c, T, nt, columns), edge_projected=dzeros(c, T, nt, columns), @@ -110,12 +111,20 @@ end # The vectorised passes are functions of their own: inside a column's closure the # loops stayed scalar. The table's lookup is a pass between them, since a gather keeps # LLVM from vectorising a loop: argon's live rates 39 ns a sample -> 10 ns. -@noinline function live_rates!(scratch, node, count, table, cap, origin, step) +@noinline function live_rates!(scratch, knots, node, count, table, cap, origin, step) + last = Int32(size(table, 2)) + # The logarithm, then each sample's knot and its distance past it, vectorised; only + # the table's four loads and the cubic stay scalar (`log_rate`'s values, bit for bit). @inbounds @simd for i in 1:count - scratch[i, node] = vlog(scratch[i, node]) + logarithm = vlog(scratch[i, node]) + j = clamp(unsafe_trunc(Int32, floor((logarithm - origin) / step)) + Int32(1), + Int32(1), last) + knots[i, node] = j + scratch[i, node] = logarithm - (origin + (j - 1) * step) end @inbounds for i in 1:count - scratch[i, node] = log_rate(scratch[i, node], table, origin, step) + j, s = knots[i, node], scratch[i, node] + scratch[i, node] = ((table[1, j] * s + table[2, j]) * s + table[3, j]) * s + table[4, j] end @inbounds @simd for i in 1:count scratch[i, node] = min(vexp(scratch[i, node]), cap) @@ -273,7 +282,7 @@ logarithm and exponential scalar and discarded them in flight (argon's rates 2.1 -> 0.7 ms a source on one thread, its plasma 4.7 ms -> 2.9 ms). A NaN field is live and stays NaN. """ -@inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args, live, scratch) +@inline function exposure_column!(rate, exposure, nodes, node, taps, dt, args, live, scratch, knots) scale, table, lower, upper, cap = args[1], args[2], args[3], args[4], args[5] origin, step = args[6], args[7] none = zero(dt) @@ -285,7 +294,7 @@ and stays NaN. scratch[live_count+1, node] = x live_count += !(x < lower) & !(x >= upper) end - live_rates!(scratch, node, live_count, table, cap, origin, step) + live_rates!(scratch, knots, node, live_count, table, cap, origin, step) @inbounds for i in 1:live_count rate[live[i, node], node] = scratch[i, node] end @@ -361,7 +370,7 @@ end function plasma_columns!(p, nodes, c, count) T = typeof(p.dt) - (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative, live, scratch) = p + (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative, live, scratch, knots) = p window, floor = c.window, p.floor args = rate_arguments(p) charge, potential = T(p.parameters[6]), T(p.parameters[7]) @@ -369,7 +378,7 @@ function plasma_columns!(p, nodes, c, count) nt = size(nodes, 1) none = zero(T) each_column!(c, count) do node - peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch) + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch, knots) # With exactly zero rates and no initial electrons both currents vanish. if iszero(peak) && iszero(initial) @inbounds for t in 1:nt @@ -468,13 +477,13 @@ end function population_columns!(p, nodes, c, first, count) T = typeof(p.dt) - (; rate, fraction, taps, dt, fractions, peaks, parts, live, scratch) = p + (; rate, fraction, taps, dt, fractions, peaks, parts, live, scratch, knots) = p floor, args = p.floor, rate_arguments(p) initial = T(p.parameters[9]) nt, reach = size(nodes, 1), 2 * (length(taps) - 1) none = zero(T) each_column!(c, count) do node - peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch) + peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch, knots) dip = rise = paid = early = largest = none before = product_before = start = none @inbounds for t in 1:nt From 710d08033498d91069339907791929cb063d6e67 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 04:25:43 +0000 Subject: [PATCH 050/107] Julia: --cuda-local, CUDA.jl on the system toolkit beside native [skip ci] On an H200 with CUDA 13.1, native's build links the system cuBLAS and CUDA.jl then loaded its own, which found the system cublasLt first: an undefined-symbol crash in every modal window. bootstrap.py --cuda-local has CUDA.jl take the local runtime (CUDA_Runtime_jll in the CUDA environment's extras, so its preference applies). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- .gitignore | 1 + julia/README.md | 1 + julia/bootstrap.py | 11 ++++++++++- julia/cuda/Project.toml | 3 +++ 4 files changed, 15 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index acb3c758d..73b3fcf5c 100644 --- a/.gitignore +++ b/.gitignore @@ -53,3 +53,4 @@ docs/introduction/lessons/searchindex .julia-runtime/ .julia-depot/ julia/LocalPreferences.toml +julia/cuda/LocalPreferences.toml diff --git a/julia/README.md b/julia/README.md index bb89214f9..90ef51a88 100644 --- a/julia/README.md +++ b/julia/README.md @@ -35,6 +35,7 @@ checksummed release): uv sync --extra julia export SOLPROP_JULIA_EXE=$(julia +1.13 -e 'print(joinpath(Sys.BINDIR, "julia"))') uv run --no-sync python julia/bootstrap.py # --cuda or --rocm for a GPU environment too +# --cuda-local: CUDA.jl on the system toolkit, beside a native build linked to it ``` The bootstrap instantiates `julia/Manifest.toml` into `.julia-depot/` diff --git a/julia/bootstrap.py b/julia/bootstrap.py index e28fcea92..f4bc726fc 100644 --- a/julia/bootstrap.py +++ b/julia/bootstrap.py @@ -78,8 +78,17 @@ def main() -> None: # --cuda (--rocm) also prepares the GPU environment, which adds CUDA.jl (AMDGPU.jl) # to the engine's. projects = ["julia"] + [ - f"julia/{gpu}" for gpu in ("cuda", "rocm") if f"--{gpu}" in sys.argv[1:] + f"julia/{gpu}" + for gpu in ("cuda", "rocm") + if f"--{gpu}" in sys.argv[1:] or (gpu == "cuda" and "--cuda-local" in sys.argv) ] + # --cuda-local: CUDA.jl takes the system toolkit rather than its own, needed where + # native is built against a system CUDA in the same process, whose cuBLAS would + # otherwise meet CUDA.jl's own (an undefined cublasLt symbol, CUDA 13.1 on an H200). + if "--cuda-local" in sys.argv[1:]: + (ROOT / "julia/cuda/LocalPreferences.toml").write_text( + '[CUDA_Runtime_jll]\nlocal = "true"\n', encoding="utf-8" + ) for project in projects: subprocess.run( [ diff --git a/julia/cuda/Project.toml b/julia/cuda/Project.toml index ba6bfa555..3cd905bc9 100644 --- a/julia/cuda/Project.toml +++ b/julia/cuda/Project.toml @@ -5,3 +5,6 @@ SolpropJulia = "bc9db228-6fd1-46b1-b175-748485922872" [sources] SolpropJulia = {path = ".."} + +[extras] +CUDA_Runtime_jll = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" From 3dabae7c05ac9a85cd4c9c52753443dc49adeb0a Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 04:26:39 +0000 Subject: [PATCH 051/107] Julia: the H200 and the latest A40 rows [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- docs/dev/benchmarks.md | 21 +++++++++++++++++++++ julia/STATUS.md | 30 ++++++++++++++++-------------- 2 files changed, 37 insertions(+), 14 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index eabae8287..d0147d8f5 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -2994,6 +2994,27 @@ Geometric means 2.32 and 2.03. One binary32 `argon_blueshift` round hung until t worker's timeout (the other ran at 2.39); `rdw`'s binary64 field differed from native's by 1.8e-11, the reordered reduction of the Adams norms, with the same steps. +**NVIDIA H200** (a rented droplet, CUDA 13.1, driver 580.196), native's CUDA build +(HOPPER90) against `julia` with CUDA.jl on the system toolkit (`bootstrap.py +--cuda-local`), `--device`, two rounds, binary64, commit `50158fa6`; every row took +native's steps with its fields to rounding: + +| case | native, s | julia, s | ratio | +|---|---:|---:|---:| +| `rdw` | 0.036 | 0.073 | 2.02 | +| `argon_blueshift` | 0.066 | 0.169 | 2.56 | +| `h2_raman_6ps` | 0.217 | 0.426 | 1.96 | +| `ctc_reduced` | 0.067 | 0.134 | 1.98 | +| `radial_filament_256` | 0.058 | 0.257 | 4.42 | +| `kerr_beam_192` | 0.181 | 0.307 | 1.69 | +| `line` | 0.058 | 0.170 | 2.92 | + +Geometric mean 2.39. On a GPU with full-rate binary64 the windows are host-bound: Nsight +Systems finds radial's kernels about 26 ms of its 0.257 s window, against 4800 launches, +670 device-to-host copies and 2300 pool allocations for two runs, and radial's split +collar keeps the Python march. Without `--cuda-local` CUDA.jl's own cuBLAS met the +system one native had loaded and every modal window crashed. + **AMD Instinct MI325X** (a rented droplet, ROCm 10.0), native's HIP build (gfx942) against `julia` with `SOLPROP_JULIA_DEVICE=rocm` (AMDGPU.jl 2.11), `--device`, two rounds, commit `196baa51`. The first run of the AMDGPU extension: the device tests diff --git a/julia/STATUS.md b/julia/STATUS.md index 62af7c8e9..9b0d55c95 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -65,20 +65,22 @@ Julia's window time over native's, 2 % of each case, both arms in one interprete same steps and binary64 fields equal to rounding (1e-13 or better); the ledger has the seconds, the machines and the earlier rows. -| case | Xeon, 1 thread | Xeon, 16 threads | A40, binary64 | A40, binary32 | MI325X, binary64 | -|---|---:|---:|---:|---:|---:| -| rdw | 1.54 | 1.14 | 2.53 | 3.27 | 2.03 | -| argon_blueshift | 1.77 | 1.30 | 2.89 | 2.39 | 2.33 | -| h2_raman_6ps | 1.25 | 0.86 | 1.14 | 0.65 | 1.71 | -| ctc_reduced | 1.85 | 1.01 | 1.56 | 1.53 | 2.27 | -| radial_filament_256 | 1.02 | 1.52 | 2.97 | 2.37 | 4.85 | -| kerr_beam_192 | 1.12 | 1.11 | 3.28 | 3.52 | 3.44 | -| line | 1.20 | 1.17 | 2.84 | 2.20 | 1.89 | - -Intel Xeon Gold 6240 (16 cores of socket 1, a shared machine) at commit `50158fa6`, -geometric mean 1.25; NVIDIA A40 against native's CUDA build at `cfa14ce7`, 2.32 and -2.03; AMD Instinct MI325X against native's HIP build at `196baa51`, 2.48, before the -GPU's column reductions. Binary32 is against native's binary64. Ratios measured before +| case | Xeon, 1 thread | Xeon, 16 threads | A40, binary64 | A40, binary32 | H200 | MI325X | +|---|---:|---:|---:|---:|---:|---:| +| rdw | 1.54 | 1.14 | 2.39 | 3.05 | 2.02 | 2.03 | +| argon_blueshift | 1.77 | 1.30 | 2.78 | 2.24 | 2.56 | 2.33 | +| h2_raman_6ps | 1.25 | 0.86 | 1.08 | 0.66 | 1.96 | 1.71 | +| ctc_reduced | 1.85 | 1.01 | 1.48 | 1.49 | 1.98 | 2.27 | +| radial_filament_256 | 1.02 | 1.52 | 2.81 | 2.27 | 4.42 | 4.85 | +| kerr_beam_192 | 1.12 | 1.11 | 3.13 | 3.63 | 1.69 | 3.44 | +| line | 1.20 | 1.17 | 2.60 | 2.24 | 2.92 | 1.89 | + +Intel Xeon Gold 6240 (16 cores of socket 1, a shared machine), the NVIDIA A40 and the +NVIDIA H200 (binary64) against native's CUDA builds, all at commit `50158fa6`: geometric +means 1.25, 2.19 (binary32 1.99) and 2.39; the AMD Instinct MI325X (binary64) against +native's HIP build at `196baa51`, before the GPU's column reductions, 2.48. On GPUs with +full-rate binary64 the windows are host-bound (the launches, copies and allocations a +step), which is what is left there. Binary32 is against native's binary64. Ratios measured before the harness fix (#557) counted 0.18 s of metadata on both arms and are not comparable. ## What is left, measured From 4d8c529d17242b7f8d6e833149f3d9bb68ed7771 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 04:39:21 +0000 Subject: [PATCH 052/107] Julia: the engine's Adams march with a split collar [skip ci] Each accepted step's commit forms the power the split finds; the march returns it with the step's length, and the adapter forms the split sums from it by JuliaBackend._finish's own operations, step by step, so a radial window's attempts, ledger, split sums and field are the Python march's bit for bit (tested). The radial windows were the one focus case left on the Python march, the outlier on the host-bound H200 and MI325X. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/march.jl | 24 +++++++++++++------ src/solprop/backends/julia/_march.py | 36 +++++++++++++++++++++------- tests/backends/test_julia.py | 12 ++++++++-- 3 files changed, 54 insertions(+), 18 deletions(-) diff --git a/julia/src/march.jl b/julia/src/march.jl index f75fcfea8..03c4c9e73 100644 --- a/julia/src/march.jl +++ b/julia/src/march.jl @@ -59,6 +59,7 @@ struct MarchConfig{R} stages::Int varying::Bool compensated::Bool + split::Bool rate::R end @@ -226,17 +227,18 @@ function march_trial!(engine, m::MarchConfig, z, dz, s) adams_trial!(engine, dz) end -"""Adopt the held trial into row `free`, commit it; return its quadrature alarm.""" -function march_accept!(engine, dz, free) +"""Adopt the held trial into row `free`, commit it; return its quadrature alarm. With +a split collar the commit also forms the power the split finds (`split_power`).""" +function march_accept!(engine, dz, free, split) adams_accept!(engine, free) - commit!(engine, Float64(dz), false) + commit!(engine, Float64(dz), split) end # --- the run --------------------------------------------------------------------------- """Hold a run's march configuration: the policy's numbers as `MarchPolicy` gives them.""" function configure_march!(engine, numbers, real_intervals, save_planes, hard_kinks, - breakpoints, stages, varying, compensated, rate_edges, rate_c) + breakpoints, stages, varying, compensated, split, rate_edges, rate_c) f = Vector{Float64}(numbers) policy = Policy(Int(f[1]), f[2] != 0, f[3], f[4], f[5], f[6], f[7], Int(f[8]), f[9], Vector{Float64}(real_intervals), f[10], f[11] != 0, Int(f[12]), @@ -246,7 +248,7 @@ function configure_march!(engine, numbers, real_intervals, save_planes, hard_kin rate = compensated ? (edges=Vector{Float64}(rate_edges), c=Array{Float64,3}(rate_c)) : nothing engine.work.march[] = MarchConfig(policy, Int(stages), Bool(varying), Bool(compensated), - rate) + Bool(split), rate) nothing end @@ -281,6 +283,8 @@ function run_march(engine, m::MarchConfig, zs, counts, hz, hp, hr, ledger, limit rows, orders = Float64[], Int[] reason, cost, floor_proposal, stage, category, message = REACHED, 0, 0.0, STAGE_NONE, 0, "" alarm, alarm_z, first_alarm = NaN, NaN, NaN + # Each accepted step's split power and length, for the adapter's split sums. + split_powers, split_steps = Vector{Float64}[], Float64[] accepted = 0 elapsed() = time() - started record(finish, dz, norm, kept, o) = @@ -363,7 +367,11 @@ function run_march(engine, m::MarchConfig, zs, counts, hz, hp, hr, ledger, limit end failed = false try - alarm = march_accept!(engine, step.dz, free) + alarm = march_accept!(engine, step.dz, free, m.split) + if m.split + push!(split_powers, split_power(engine)) + push!(split_steps, step.dz) + end catch error fail(ACCEPT, error) failed = true @@ -418,7 +426,9 @@ function run_march(engine, m::MarchConfig, zs, counts, hz, hp, hr, ledger, limit history_z=hz, history_predicted=hp, history_row=hr, ledger=ledger, rows=rows, orders=orders, reason=reason, cost=cost, floor_proposal=floor_proposal, stage=stage, category=category, message=message, alarm=alarm, alarm_z=alarm_z, - first_alarm=first_alarm) + first_alarm=first_alarm, + split_powers=isempty(split_powers) ? zeros(0, 0) : reduce(hcat, split_powers), + split_steps=split_steps) end const configure_march_b = configure_march! diff --git a/src/solprop/backends/julia/_march.py b/src/solprop/backends/julia/_march.py index 14e2bf002..541c5047c 100644 --- a/src/solprop/backends/julia/_march.py +++ b/src/solprop/backends/julia/_march.py @@ -14,9 +14,10 @@ native's ``_NativeAdamsMarch``. A configuration the Julia march does not cover runs the Python march -(:attr:`JuliaAdamsMarch.refusal`): a replayed schedule, a split collar, interpolated -planes, the carrier frame, a compensated trial without an expansion's rate table, or -``SOLPROP_JULIA_MARCH=host``. +(:attr:`JuliaAdamsMarch.refusal`): a replayed schedule, interpolated planes, the +carrier frame, a compensated trial without an expansion's rate table, or +``SOLPROP_JULIA_MARCH=host``. A split collar's sums are formed from the power each +accepted step's commit found, by the adapter, as its own commit does. """ import logging @@ -77,7 +78,7 @@ def __init__(self, backend: Any, method: Multistep) -> None: # The driver's protected bookkeeping, which this march books into exactly as # solprop's does (``DRIVER_SURFACE``), as native's march reaches it. self._driver: Any = backend - self._configured: tuple[float | None] | None = None + self._configured: tuple[float | None, bool] | None = None self.refusal = self._refusal() """Why the Python march steps the run, or ``None`` when Julia's does.""" @@ -88,15 +89,12 @@ def native(self) -> bool: def _refusal(self) -> str | None: """Return why the Julia march does not step the run, or ``None``.""" - from solprop.backends.julia._backend import _splits # noqa: PLC0415 - cycle - problem = self._driver._problem engine: Any = self._engine reasons = ( (os.environ.get("SOLPROP_JULIA_MARCH") == "host", "asked for"), (self._exponential is None, "not the exponential formulation"), (problem.stepper.schedule is not None, "a replayed schedule"), - (_splits(problem), "a split collar"), (self._interpolate, "interpolated planes"), (self._policy.carrier, "the carrier frame"), ( @@ -127,9 +125,14 @@ def march_to(self, target: float) -> None: def _configure(self) -> None: """Hand the engine the run's policy, again when the monitor's interval moved.""" + from solprop.backends.julia._backend import _splits # noqa: PLC0415 - cycle + monitor = self._driver._monitor interval = None if monitor is None else float(monitor.interval) - if self._configured == (interval,): + split = bool( + _splits(self._driver._problem) and self._driver._split_monitor is not None + ) + if self._configured == (interval, split): return policy = self._policy backend = self._driver @@ -174,12 +177,13 @@ def _configure(self) -> None: len(problem.stepper.tableau.nodes), bool(backend._varying), bool(engine.compensated), + split, np.ascontiguousarray(edges, dtype=np.float64), np.ascontiguousarray(coefficients, dtype=np.float64) if engine.compensated else np.zeros((0, 0, 0)), ) - self._configured = (interval,) + self._configured = (interval, split) def _bounds(self, target: float) -> tuple[np.ndarray, np.ndarray]: """Return a call's bounds: the target, and the steps the driver has work on. @@ -330,6 +334,20 @@ def _synchronise(self, result: Any) -> None: setattr(ledger, name, int(value)) orders = np.asarray(result.orders).tolist() ledger.orders.extend(int(order) for order in orders) + steps = np.asarray(result.split_steps).tolist() + if steps: + # Each accepted step's split sums from the power its commit found, by the + # operations `JuliaBackend._finish` performs, step by step. + powers = np.asarray(result.split_powers) + monitor = backend._split_monitor + rate = monitor.weights[3] + for index, dz in enumerate(steps): + power = np.ascontiguousarray(powers[:, index]) + half = power * np.exp(-0.5 * rate * dz) + backend._split_removed += float(power @ -np.expm1(-rate * dz)) + backend._split_found = np.concatenate( + [[half.sum()], monitor.weights[:3] @ half] + ) if orders: # The accepted steps' commits, which the engine made: what `_finish` sets. backend._alarm = float(result.alarm) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 855c8a769..65603eeba 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -376,6 +376,8 @@ def _march(configuration, march): (ledger.startup, ledger.predictor, ledger.rejected, ledger.accepted_steps), (ledger.rejected_steps, ledger.restarts, ledger.failure_restarts), list(ledger.orders), + engine._split_removed, + None if engine._split_found is None else engine._split_found.tolist(), ) engine.close() return field, record @@ -383,12 +385,18 @@ def _march(configuration, march): @pytest.mark.parametrize( ("case", "fraction"), - [("rdw", 0.002), ("argon_blueshift", 0.002), ("ctc_reduced", 0.002)], + [ + ("rdw", 0.002), + ("argon_blueshift", 0.002), + ("ctc_reduced", 0.002), + ("radial_filament_256", 0.002), + ], ) def test_julia_march_is_the_python_march(runtime, monkeypatch, case, fraction): """Julia's Adams march takes the Python march's decisions on the same engine. - The same attempts, ledger and accepted orders, and the same field bit for bit; + The same attempts, ledger and accepted orders, the same split collar sums (radial), + and the same field bit for bit; estimated FFT plans, since a measured plan may differ from one process to the next. """ del runtime From 3fd4a09f40e29c22fa017827655f300c2f59b56a Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 04:44:58 +0000 Subject: [PATCH 053/107] Julia: a GPU's scratch arrays kept by the engine, not allocated a call [skip ci] The device reductions' scratch, the collar's factor and the heavy reductions' terms come from a cache in the config keyed by use, type and shape: a trial made dozens of pool allocations on an H200. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 2 +- julia/src/dopri.jl | 2 +- julia/src/launch.jl | 21 +++++++++++---------- julia/src/observe.jl | 6 ++---- 4 files changed, 15 insertions(+), 16 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 8302f00ab..222c8fbce 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -66,7 +66,7 @@ function create(input) FFTW.set_num_threads(1) BLAS.set_num_threads(1) c = ( - backend=backend, T=T, tasks=host.int("threads"), + backend=backend, T=T, tasks=host.int("threads"), scratch=Dict{Any,Any}(), fft_threads=host.int("fft_threads"), raman_fft_threads=host.has("raman_fft_threads") ? host.int("raman_fft_threads") : host.int("fft_threads"), transverse_fft_threads=host.has("transverse_fft_threads") ? host.int("transverse_fft_threads") : host.int("fft_threads"), diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 6f2762e5d..ef66d3a8c 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -161,7 +161,7 @@ end """The collar's half-step factor a sample, `exp(half rate[t]) inverse`, formed once a sample rather than once an element (384 modes each took the same exponential).""" function collar_factor(rate, half, inverse, c) - factor = similar(rate) + factor = oncpu(c) ? similar(rate) : scratch(c, :collar, eltype(rate), length(rate)) each!(c, length(rate), 1) do t, _ @inbounds factor[t] = exp(half * rate[t]) * inverse end diff --git a/julia/src/launch.jl b/julia/src/launch.jl index d28e6ad34..886bfaffb 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -97,10 +97,15 @@ function each_on!(f::F, backend, tasks, nt, nm, heavy) where {F} nothing end +"""A device scratch array the engine keeps (`c.scratch`), by its use, type and shape: a +GPU's pool allocations a trial were dozens.""" +scratch(c, use::Symbol, T, dims...) = + get!(() -> KA.allocate(c.backend, T, dims...), c.scratch, (use, T, dims)) + """`f(t, m)` at every sample, into a device scratch matrix of `out`'s element type, for a device reduction over its rows or columns.""" -function reduce_terms(f::F, c, out, nt, nm) where {F} - scratch = KA.allocate(c.backend, eltype(out), nt, nm) +function reduce_terms(f::F, c, out, nt, nm; use=:terms) where {F} + scratch = SolpropJulia.scratch(c, use, eltype(out), nt, nm) each!(c, nt, nm) do t, m @inbounds scratch[t, m] = f(t, m) end @@ -141,11 +146,9 @@ function rowsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} # A thread a row looped over every column (36864 for a Cartesian plane): the # terms fill a scratch matrix in parallel and the device's reduction sums it. scratch = reduce_terms(f, c, out, nt, nm) - total = KA.allocate(c.backend, eltype(out), nt, 1) + total = SolpropJulia.scratch(c, :rows, eltype(out), nt, 1) sum!(total, scratch) out .+= vec(total) - KA.unsafe_free!(scratch) - KA.unsafe_free!(total) end nothing end @@ -176,14 +179,12 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=fa # A heavy body a thread: AK's reduction gives each thread several elements # (six blocks for rdw's 10244, its predictor 539 us a trial on an A40), so the # bodies run as an elementwise kernel into scratch and only the sums reduce. - scratch = KA.allocate(c.backend, typeof(neutral), nt * nm) + scratch = SolpropJulia.scratch(c, :heavy, typeof(neutral), nt * nm) each!(c, nt, nm) do t, m @inbounds scratch[t+(m-1)*nt] = f(t, m) end - total = AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, - neutral=neutral) - KA.unsafe_free!(scratch) - return total + return AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, + neutral=neutral) end AK.mapreduce(op, 1:nt*nm; backend=c.backend, init=neutral, neutral=neutral) do i m = (i - 1) ÷ nt + 1 diff --git a/julia/src/observe.jl b/julia/src/observe.jl index 261ad7373..abf0ee848 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -169,7 +169,6 @@ function colsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} # A thread a column left most of the device idle: a parallel fill and a sum. scratch = reduce_terms(f, c, out, nt, nm) sum!(reshape(out, 1, :), scratch) - KA.unsafe_free!(scratch) return nothing end each_column!(c, nm) do m @@ -429,10 +428,10 @@ function spatial_local!(engine, dt, conversion) fluxes = reduce_terms(c, fluence, nt, width) do t, n @inbounds flux * real(signal[t, n] * conj(other[t, n])) * factor end - products = reduce_terms(c, fluence, nt, width) do t, n + products = reduce_terms(c, fluence, nt, width; use=:products) do t, n @inbounds abs(signal[t, n]) * abs(other[t, n]) * factor end - totals, sizes, highest = (KA.allocate(c.backend, T, 1, width) for _ in 1:3) + totals, sizes, highest = (scratch(c, use, T, 1, width) for use in (:totals, :sizes, :peaks)) sum!(totals, fluxes) sum!(sizes, products) maximum!(highest, fluxes) @@ -443,7 +442,6 @@ function spatial_local!(engine, dt, conversion) peaks[first+n-1] = highest[1, n] end end - foreach(KA.unsafe_free!, (fluxes, products, totals, sizes, highest)) end end (Vector{Float64}(Array(fluence)), Vector{Float64}(Array(magnitudes)), From 5f5efcf835b63416b70b4c19d9884db262dc758e Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 05:30:55 +0000 Subject: [PATCH 054/107] Julia: the A40 rows at 50158fa6 and 3fd4a09f [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- docs/dev/benchmarks.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index d0147d8f5..38284f74d 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -2994,6 +2994,13 @@ Geometric means 2.32 and 2.03. One binary32 `argon_blueshift` round hung until t worker's timeout (the other ran at 2.39); `rdw`'s binary64 field differed from native's by 1.8e-11, the reordered reduction of the Adams norms, with the same steps. +At `50158fa6` (the GPU's device reductions) binary64 gave 2.19 and binary32 1.99, and at +`3fd4a09f` (radial on the engine's march, the GPU's scratch kept) 2.27 and 2.03 on +another A40 node. Radial's window rose from 0.479 s to 0.530 s there, outside both +spreads, while `rdw` and `line`, which those commits did not change, rose too (0.129 to +0.136 s, 0.247 to 0.258 s): whether the march costs radial on a GPU is not established. +Binary32 `h2_raman_6ps` at 0.61. No window hung in either. + **NVIDIA H200** (a rented droplet, CUDA 13.1, driver 580.196), native's CUDA build (HOPPER90) against `julia` with CUDA.jl on the system toolkit (`bootstrap.py --cuda-local`), `--device`, two rounds, binary64, commit `50158fa6`; every row took From a6722029347f825e6be3e3e731493b919a1023cc Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 06:35:55 +0000 Subject: [PATCH 055/107] Julia: a timed run's first window compiles (almost) nothing [skip ci] The benchmark worker warms up without a boundary monitor, so the monitor's bindings, the split collar's returns and the march's rejection first ran inside the timed window, each compiling there: 252 ms of a 0.63 s radial window, 80 ms of a 0.21 s line one, 97 ms of Cartesian's. The construction warms every monitor binding's bridge types, the real binding passes the warm-up's writable arrays, the split powers return as a vector, and the march's remaining decisions precompile. Radial's window 0.63 s -> 0.40 s, line's 0.21 s -> 0.14 s on 16 Xeon threads (native's 0.37 s and 0.18 s); tested. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/march.jl | 22 ++++++++++-- src/solprop/backends/julia/_backend.py | 16 +++++++-- src/solprop/backends/julia/_march.py | 2 +- tests/backends/test_julia.py | 47 ++++++++++++++++++++++++++ 4 files changed, 80 insertions(+), 7 deletions(-) diff --git a/julia/src/march.jl b/julia/src/march.jl index 03c4c9e73..49c549c71 100644 --- a/julia/src/march.jl +++ b/julia/src/march.jl @@ -190,6 +190,9 @@ function approach(p::Policy, z, stop, target) end proposal(p::Policy, dz, f) = py_min(dz * f, p.dz_max) +"""`TransverseEdge.due`: read here when the next proposal would carry past the read.""" +read_due(has_read_at, read_at, z, ahead) = + has_read_at && z + ahead >= read_at - 1e-12 * py_max(abs(z), 1.0) reached(position, target, ulps) = position >= target - ulps * ulp(py_max(abs(position), abs(target))) @@ -296,7 +299,6 @@ function run_march(engine, m::MarchConfig, zs, counts, hz, hp, hr, ledger, limit message = sprint(showerror, error) category = error isa ArgumentError ? VALUE : BACKEND end - read_due(z, ahead) = has_read_at && z + ahead >= read_at - 1e-12 * py_max(abs(z), 1.0) while !reached(z, target, p.landing_ulps) # The budget, before any call is made (`_afford`). need = (isempty(hz) ? 1 : 0) + 1 @@ -406,7 +408,8 @@ function run_march(engine, m::MarchConfig, zs, counts, hz, hp, hr, ledger, limit reason = REACHED @goto done end - if (host_step > 0 && accepted == host_step) || read_due(z, proposed) + if (host_step > 0 && accepted == host_step) || + read_due(has_read_at, read_at, z, proposed) reason = HOST_STEP @goto done end @@ -427,9 +430,22 @@ function run_march(engine, m::MarchConfig, zs, counts, hz, hp, hr, ledger, limit orders=orders, reason=reason, cost=cost, floor_proposal=floor_proposal, stage=stage, category=category, message=message, alarm=alarm, alarm_z=alarm_z, first_alarm=first_alarm, - split_powers=isempty(split_powers) ? zeros(0, 0) : reduce(hcat, split_powers), + # Flat (a step's power after another): a vector's buffer path is compiled already. + split_powers=isempty(split_powers) ? Float64[] : reduce(vcat, split_powers), split_steps=split_steps) end +# The decisions a warm-up's one accepted attempt does not reach compile into the +# package image, not inside a run's first window (a rejection there took 9 ms). +for T in (Int,) + precompile(rejection, (Policy, Float64, T, T, T)) + precompile(read_due, (Bool, Float64, Float64, Float64)) + precompile(choose_order, (Policy, NamedTuple{(:nodes, :rows, :held, :order, :orders), + Tuple{Vector{Float64}, Vector{T}, T, T, Vector{T}}}, + Vector{Float64}, Float64, Bool)) + precompile(next_landing, (Policy, Float64, Float64)) + precompile(collar_reentry, (Policy, Float64, T, Bool, Bool)) +end + const configure_march_b = configure_march! const march_run_b = march_run! diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index f31be455a..13b82e0b4 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -547,7 +547,13 @@ def _warm_bridge(self) -> None: jl, engine = self._jl, self._engine # A crossing's bucket table is read-only, which is part of its bridge type. buckets = np.zeros((n_modes, n_omega), dtype=np.uint8) - for columns, table in ((None, None), (np.ones(n_modes), buckets.T)): + # Every combination a monitor binds: each is a method of its own. + for columns, table in ( + (None, None), + (np.ones(n_modes), None), + (None, buckets.T), + (np.ones(n_modes), buckets.T), + ): call_julia(jl.bind_monitor_b, engine, columns, table) for name in ("state_power", "occupancy", "split_power", "column_energy"): np.asarray(call_julia(getattr(jl, name), engine)) @@ -849,13 +855,17 @@ def _bind_monitor(self, monitor: BoundaryMonitor | None) -> None: if monitor is None: return crossing = monitor.crossing + # Writable copies, as the warm-up passes: a read-only array is another bridge + # type, and its method compiled inside the first window (118 ms on radial). call_julia( self._jl.bind_monitor_b, self._engine, - None if monitor.columns is None else np.asarray(monitor.columns), + None + if monitor.columns is None + else np.array(monitor.columns, dtype=np.float64, copy=True), None if crossing is None - else np.ascontiguousarray(crossing.buckets, dtype=np.uint8).T, + else np.array(crossing.buckets, dtype=np.uint8, copy=True).T, ) def _edge_reading( diff --git a/src/solprop/backends/julia/_march.py b/src/solprop/backends/julia/_march.py index 541c5047c..881083d35 100644 --- a/src/solprop/backends/julia/_march.py +++ b/src/solprop/backends/julia/_march.py @@ -338,7 +338,7 @@ def _synchronise(self, result: Any) -> None: if steps: # Each accepted step's split sums from the power its commit found, by the # operations `JuliaBackend._finish` performs, step by step. - powers = np.asarray(result.split_powers) + powers = np.asarray(result.split_powers).reshape(len(steps), -1).T monitor = backend._split_monitor rate = monitor.weights[3] for index, dz in enumerate(steps): diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 65603eeba..7c1be02c6 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -408,3 +408,50 @@ def test_julia_march_is_the_python_march(runtime, monkeypatch, case, fraction): reference, reference_record = _march(configuration, "host") assert record == reference_record np.testing.assert_array_equal(field, reference) + + +@pytest.mark.filterwarnings("ignore::solprop.exceptions.BoundaryWarning") +@pytest.mark.parametrize( + ("case", "fraction"), [("radial_filament_256", 0.002), ("line", 0.005)] +) +def test_julia_first_window_compiles_nothing(runtime, case, fraction): + """After the benchmark worker's warm-up, a timed run compiles (almost) nothing. + + The warm-up propagates without a boundary monitor, so the monitor's bindings and + the split collar's march first run inside the window: each bridge type compiled + there cost up to 0.25 s of a radial window until the construction warmed them. + """ + del runtime + from benchmarks.worker import timed_run # noqa: PLC0415 + from juliacall import Main # noqa: PLC0415 + + from solprop.driver.run import field_retention # noqa: PLC0415 + + configuration = CASES[case].configuration( + "default", 2, "julia", fraction=fraction, noise="none" + ) | {"warmup": 0.02} + simulation = build(configuration) + problem = simulation.translate() + engine = select( + "julia", + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + retention = field_retention( + problem, simulation.settings.fields, simulation.settings.field_planes + ) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(configuration["warmup"] * configuration["stop"]) + engine.observe(field=True) + engine.stats(problem.stats_spec) + Main.seval("Base.cumulative_compile_timing(true)") + compiled = Main.seval("() -> Base.cumulative_compile_time_ns()[1]") + compiled() + before = compiled() + timed_run(simulation, problem, engine, retention, simulation._boundary_monitor()) + # Some tens of milliseconds of inference the compile trace does not list remain + # (about 21 on radial); a bridge type left to the window cost 50 to 250. + assert (compiled() - before) / 1e6 < 50.0 + engine.close() From d4374968bbf10a691a2fb9364a5ec649d595600d Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 07:36:16 +0000 Subject: [PATCH 056/107] Julia: the clean CPU A/B at a6722029 and the A40's binary64 [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- docs/dev/benchmarks.md | 24 ++++++++++++++++++++++++ julia/STATUS.md | 25 ++++++++++++++----------- 2 files changed, 38 insertions(+), 11 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 38284f74d..10e250385 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -2955,6 +2955,25 @@ Geometric mean 1.25 (1.42 at `7c7ac9b7`). The load spread some rounds widely (`h2_raman_6ps` 0.59 to 0.88 and `kerr_beam_192` 0.67 to 1.35 on 16 threads); the ratios are medians of paired rounds, both arms under the same load. +And at commit `a6722029`, three rounds on a quiet machine (load 0.3 to 2.2). Until this +commit every Julia row above carried compilation inside its window: the worker's +warm-up runs without a boundary monitor, so the monitor's bindings and radial's split +collar first ran, and compiled, in the timed run (252 ms of a radial window, 80 ms of +`line`'s, 97 ms of `kerr_beam_192`'s). The construction now warms them +(`test_julia_first_window_compiles_nothing`): + +| case | native 1 thread, s | julia | ratio | native 16 threads, s | julia | ratio | +|---|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.416 | 0.632 | 1.52 | 0.143 | 0.148 | 1.04 | +| `argon_blueshift` | 0.544 | 0.839 | 1.51 | 0.181 | 0.219 | 1.21 | +| `h2_raman_6ps` | 3.395 | 4.216 | 1.24 | 1.923 | 1.714 | 0.89 | +| `ctc_reduced` | 1.007 | 1.573 | 1.56 | 0.378 | 0.344 | 0.90 | +| `radial_filament_256` | 2.157 | 2.111 | 0.97 | 0.367 | 0.407 | 1.12 | +| `kerr_beam_192` | 5.149 | 5.671 | 1.10 | 0.851 | 1.070 | 1.26 | +| `line` | 0.675 | 0.730 | 1.08 | 0.181 | 0.141 | 0.78 | + +Geometric mean 1.13; Julia faster than native in four rows. + **NVIDIA A40** (driver 595.71), native's CUDA build (AMPERE86) against `julia` with `SOLPROP_JULIA_DEVICE=cuda` (CUDA.jl 6.5), `--device`, two rounds, commit `7c7ac9b7`: @@ -3001,6 +3020,11 @@ spreads, while `rdw` and `line`, which those commits did not change, rose too (0 0.136 s, 0.247 to 0.258 s): whether the march costs radial on a GPU is not established. Binary32 `h2_raman_6ps` at 0.61. No window hung in either. +At `a6722029` (the first window no longer compiling) binary64 gave 1.97: `rdw` 2.86, +`argon_blueshift` 2.80, `h2_raman_6ps` 1.02, `ctc_reduced` 1.47, radial 2.05 (0.354 s), +`kerr_beam_192` 2.75, `line` 1.68. The binary32 arm of the same job was erratic (`rdw`'s +rounds 2.5 and 20.9 against steady native times), under investigation. + **NVIDIA H200** (a rented droplet, CUDA 13.1, driver 580.196), native's CUDA build (HOPPER90) against `julia` with CUDA.jl on the system toolkit (`bootstrap.py --cuda-local`), `--device`, two rounds, binary64, commit `50158fa6`; every row took diff --git a/julia/STATUS.md b/julia/STATUS.md index 9b0d55c95..e32193f43 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -53,6 +53,8 @@ Measured step by step on an Intel Xeon Gold 6240 (16 cores of one socket) unless | A varying guide's power weight rebound alone, warmed at construction | `rdw`'s 12 planes 37 ms of binding -> none | | GPU: heavy reductions a thread an element; batched transforms; one kernel a trapezoid increment | the A40's binary64 geometric mean 2.77 -> 2.32 | | GPU: column and row sums, local sums and occupancy by device reductions | (from the MI325X's trace; measured in the ledger) | +| The split collar on the engine's march; a plasma integral's FIR in one pass | radial off the Python march; `ctc_reduced`'s integral 0.50 ms -> 0.27 ms | +| Nothing left to compile in a run's first window | radial on 16 threads 0.63 s -> 0.40 s, `line` 0.21 s -> 0.14 s (the worker's warm-up runs without a monitor) | The vectorised functions paid only once the live samples were gathered and each pass was a function of its own: in the column's branchy loop, and inside its closure, LLVM @@ -67,17 +69,18 @@ seconds, the machines and the earlier rows. | case | Xeon, 1 thread | Xeon, 16 threads | A40, binary64 | A40, binary32 | H200 | MI325X | |---|---:|---:|---:|---:|---:|---:| -| rdw | 1.54 | 1.14 | 2.39 | 3.05 | 2.02 | 2.03 | -| argon_blueshift | 1.77 | 1.30 | 2.78 | 2.24 | 2.56 | 2.33 | -| h2_raman_6ps | 1.25 | 0.86 | 1.08 | 0.66 | 1.96 | 1.71 | -| ctc_reduced | 1.85 | 1.01 | 1.48 | 1.49 | 1.98 | 2.27 | -| radial_filament_256 | 1.02 | 1.52 | 2.81 | 2.27 | 4.42 | 4.85 | -| kerr_beam_192 | 1.12 | 1.11 | 3.13 | 3.63 | 1.69 | 3.44 | -| line | 1.20 | 1.17 | 2.60 | 2.24 | 2.92 | 1.89 | - -Intel Xeon Gold 6240 (16 cores of socket 1, a shared machine), the NVIDIA A40 and the -NVIDIA H200 (binary64) against native's CUDA builds, all at commit `50158fa6`: geometric -means 1.25, 2.19 (binary32 1.99) and 2.39; the AMD Instinct MI325X (binary64) against +| rdw | 1.52 | 1.04 | 2.86 | 3.05 | 2.02 | 2.03 | +| argon_blueshift | 1.51 | 1.21 | 2.80 | 2.24 | 2.56 | 2.33 | +| h2_raman_6ps | 1.24 | 0.89 | 1.02 | 0.66 | 1.96 | 1.71 | +| ctc_reduced | 1.56 | 0.90 | 1.47 | 1.49 | 1.98 | 2.27 | +| radial_filament_256 | 0.97 | 1.12 | 2.05 | 2.27 | 4.42 | 4.85 | +| kerr_beam_192 | 1.10 | 1.26 | 2.75 | 3.63 | 1.69 | 3.44 | +| line | 1.08 | 0.78 | 1.68 | 2.24 | 2.92 | 1.89 | + +Intel Xeon Gold 6240 (16 cores of socket 1, quiet) and the NVIDIA A40 (binary64) at +commit `a6722029`, geometric means 1.13 and 1.97; the A40's binary32 and the NVIDIA H200 +(binary64) at `50158fa6`, 1.99 and 2.39, before the first window stopped compiling, which +cost radial and the free-space windows most (radial 0.53 s -> 0.35 s on the A40); the AMD Instinct MI325X (binary64) against native's HIP build at `196baa51`, before the GPU's column reductions, 2.48. On GPUs with full-rate binary64 the windows are host-bound (the launches, copies and allocations a step), which is what is left there. Binary32 is against native's binary64. Ratios measured before From a108ae5d1a3fd4cef8f0565eef2ba2bbc7d34d61 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 07:42:52 +0000 Subject: [PATCH 057/107] Julia: the A40's binary32 rerun at a6722029 [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- docs/dev/benchmarks.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 10e250385..95baee386 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3023,7 +3023,10 @@ Binary32 `h2_raman_6ps` at 0.61. No window hung in either. At `a6722029` (the first window no longer compiling) binary64 gave 1.97: `rdw` 2.86, `argon_blueshift` 2.80, `h2_raman_6ps` 1.02, `ctc_reduced` 1.47, radial 2.05 (0.354 s), `kerr_beam_192` 2.75, `line` 1.68. The binary32 arm of the same job was erratic (`rdw`'s -rounds 2.5 and 20.9 against steady native times), under investigation. +rounds 2.5 and 20.9 against steady native times); rerun on another node (its host load +about 12 from other jobs), three rounds, it gave `rdw` 2.48, radial 1.39 (0.233 s), +`ctc_reduced` 1.37 and `line` 1.59: the Julia arm's host work makes it the more +sensitive to a busy node. **NVIDIA H200** (a rented droplet, CUDA 13.1, driver 580.196), native's CUDA build (HOPPER90) against `julia` with CUDA.jl on the system toolkit (`bootstrap.py From 5264734529eeb2cf0b5f0da66a7279e04035a648 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 08:59:18 +0000 Subject: [PATCH 058/107] Julia: the benchmark windows' specialisations precompiled into the package image [skip ci] A process's first engine compiled 34 to 64 s of specialisations at construction (the engine's methods specialise on its configuration's types). The windows' compile traces, recorded with juliacall's PYTHON_JULIACALL_TRACE_COMPILE over every focus case at one and sixteen threads, are replayed when the package is built (66 s, once): the first construction 11 to 14 s, of which about 10 s compilation still. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/src/SolpropJulia.jl | 16 + julia/src/precompile_trace.jl | 1608 +++++++++++++++++++++++++++++++++ 2 files changed, 1624 insertions(+) create mode 100644 julia/src/precompile_trace.jl diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 222c8fbce..cc317a4d3 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -214,4 +214,20 @@ const commit_b = commit! const evaluate_b = evaluate! const reset_work_b = reset_work! + +# The specialisations the benchmark windows compiled (every focus case, binary64, one +# and sixteen threads), replayed when the package is built so that their native code is +# in its image: `julia/src/precompile_trace.jl`, recorded with juliacall's +# `PYTHON_JULIACALL_TRACE_COMPILE`. A statement that no longer resolves is skipped. +import KernelAbstractions, AcceleratedKernels, FFTW, Polyester, Atomix +let file = joinpath(@__DIR__, "precompile_trace.jl") + if ccall(:jl_generating_output, Cint, ()) == 1 && isfile(file) + for line in eachline(file) + try + Base.eval(@__MODULE__, Meta.parse(line)) + catch + end + end + end +end end diff --git a/julia/src/precompile_trace.jl b/julia/src/precompile_trace.jl new file mode 100644 index 000000000..6589eaebf --- /dev/null +++ b/julia/src/precompile_trace.jl @@ -0,0 +1,1608 @@ +precompile(Tuple{AcceleratedKernels.var"##Auto#5", Bool, Type{AcceleratedKernels.Auto}}) +precompile(Tuple{Adapt.var"##3#4", Vararg{Any, 4}}) +precompile(Tuple{ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_index)}, Int64}) +precompile(Tuple{ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_shape)}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}}, Int64}) +precompile(Tuple{Base.Broadcast.var"#copy##0#copy##1"{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{3}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}}, Int64}) +precompile(Tuple{Base.Fix{2, typeof(Base.:(var"==")), Int64}, Int64}) +precompile(Tuple{Base.Iterators.var"#IteratorEltype##0#IteratorEltype##1"{Tuple{Array{PythonCall.Py, 1}, Array{Array{String, 1}, 1}}}, Int64}) +precompile(Tuple{Base.Iterators.var"#IteratorSize##0#IteratorSize##1"{Tuple{Array{PythonCall.Py, 1}, Array{Array{String, 1}, 1}}}, Int64}) +precompile(Tuple{Base.Iterators.var"#IteratorSize##2#IteratorSize##3"{Tuple{Array{Tuple{Int64, Int64}, 1}, Base.UnitRange{Int64}}}, Int64}) +precompile(Tuple{Base.Iterators.var"#IteratorSize##2#IteratorSize##3"{Tuple{Base.UnitRange{Int64}, Base.UnitRange{Int64}}}, Int64}) +precompile(Tuple{Base.JuliaSyntax.var"#invoke_fixedworld#95#fix_world_age##3"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}, Base.Pairs{Symbol, Union{}, Nothing, NamedTuple{(), Tuple{}}}, Base.JuliaSyntax.var"#invoke_fixedworld#fix_world_age##2"{Base.JuliaSyntax.var"#invoke_fixedworld#95#fix_world_age##3"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}}, Core.SimpleVector, Vararg{Any}}) +precompile(Tuple{Base.JuliaSyntax.var"#invoke_fixedworld#fix_world_age##2"{Base.JuliaSyntax.var"#invoke_fixedworld#95#fix_world_age##3"{typeof(Base.JuliaSyntax.core_parser_hook), UInt64}}, Core.SimpleVector, Vararg{Any}}) +precompile(Tuple{Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Float64}, Int64}) +precompile(Tuple{BitTwiddlingConvenienceFunctions.var"##1#2", Any, Any, Any}) +precompile(Tuple{GPUCompiler.LowerGCFrame, LLVM.Function}) # recompile +precompile(Tuple{GPUCompiler.var"##275#276", Vararg{Any, 11}}) +precompile(Tuple{GPUCompiler.var"##emit_llvm#248", Bool, typeof(GPUCompiler.emit_llvm), GPUCompiler.CompilerJob{T, P} where P where T}) # recompile +precompile(Tuple{KernelAbstractions.POCL.var"#61#62"{typeof(KernelAbstractions.POCL.POCLKernels.gpu_fill_kernel), Base.Some{Type}, NamedTuple{(:name,), Tuple{Nothing}}}}) +precompile(Tuple{KernelAbstractions.var"##48#49", Any, Any, Any}) # recompile +precompile(Tuple{LayoutPointers.var"##1#2", Vararg{Any, 5}}) +precompile(Tuple{LLVM.Interop.var"##11#12", Vararg{Any, 10}}) # recompile +precompile(Tuple{LLVM.Interop.var"#14#15", LLVM.IRBuilder, Array{Any, 1}, Array{Any, 1}}) # recompile +precompile(Tuple{Main.var"#2#3", String}) +precompile(Tuple{ManualMemory.var"##1#2", Any, Any, Any}) +precompile(Tuple{ManualMemory.var"##3#4", Vararg{Any, 4}}) +precompile(Tuple{ManualMemory.var"##5#6", Any, Any, Any}) +precompile(Tuple{ManualMemory.var"##7#8", Vararg{Any, 5}}) +precompile(Tuple{ManualMemory.var"##9#10", Vararg{Any, 5}}) +precompile(Tuple{Polyester.var"##1#2", Vararg{Any, 9}}) +precompile(Tuple{Polyester.var"##6#7", Vararg{Any, 17}}) +precompile(Tuple{PythonCall.Convert.var"##19#20", Any, Any, Any}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Any, typeof(PythonCall.JlWrap.pyconvert_rule_jlvalue)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Array{Any, 1}, typeof(PythonCall.Convert.pyconvert_rule_iterable)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Array{Any, 1}, typeof(PythonCall.Convert.pyconvert_rule_iterable)}, PythonCall.Py}) # recompile +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Bool, typeof(PythonCall.Convert.pyconvert_rule_bool)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Float64, typeof(PythonCall.Convert.pyconvert_rule_float)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Integer, typeof(PythonCall.Convert.pyconvert_rule_int)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{NamedTuple{names, T} where T<:Tuple where names, typeof(PythonCall.Convert.pyconvert_rule_iterable)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{PythonCall.PyArray{T, N, M, L, R} where R where L where M where N where T, typeof(PythonCall.Wrap.pyconvert_rule_array_nocopy)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{PythonCall.PyDict{K, V} where V where K, typeof(PythonCall.Wrap.pyconvert_rule_mapping)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{String, typeof(PythonCall.Convert.pyconvert_rule_str)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyconvert_fix##0#pyconvert_fix##1"{Tuple, typeof(PythonCall.Convert.pyconvert_rule_iterable)}, PythonCall.Py}) +precompile(Tuple{PythonCall.Convert.var"#pyisin#_pyconvert_get_rules##0", PythonCall.Py, Array{PythonCall.Py, 1}}) +precompile(Tuple{PythonCall.Utils.var"##4#5", Any, Any, Any}) +precompile(Tuple{PythonCall.Utils.var"##6#7", Any, Any, Any}) +precompile(Tuple{PythonCall.Utils.var"##8#9", Any, Any, Any}) +precompile(Tuple{SolpropJulia.var"#better#landing##0", Tuple{Float64, Int64, Float64}, Tuple{Float64, Int64, Float64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_bfft!), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_bfft), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_bfft!), Array{Base.Complex{Float64}, 3}, Tuple{Int64, Int64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_fft!), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_fft), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_fft!), Array{Base.Complex{Float64}, 3}, Tuple{Int64, Int64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, typeof(AbstractFFTs.plan_rfft), Array{Float64, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, typeof(AbstractFFTs.plan_bfft!), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, typeof(AbstractFFTs.plan_fft!), Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"##plan#26", Int64, Int64, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, typeof(AbstractFFTs.plan_rfft), Array{Float64, 2}, Int64}) +precompile(Tuple{SolpropJulia.var"#record#run_march##1"{SolpropJulia.var"#elapsed#run_march##0"{Float64}}, Float64, Float64, Float64, Bool, Int64}) +precompile(Tuple{StaticArrayInterface.var"##35#36", Vararg{Any, 12}}) +precompile(Tuple{StaticArrayInterface.var"##46#47", Vararg{Any, 5}}) +precompile(Tuple{StaticArrayInterface.var"#_accum_dims##0#_accum_dims##1"{Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}, Int64}) +precompile(Tuple{StaticArrayInterface.var"#_accum_dims##0#_accum_dims##1"{Tuple{Int64, Int64}, Tuple{Int64, Int64}}, Int64}) +precompile(Tuple{StaticArrayInterface.var"#rank_to_sortperm##0#rank_to_sortperm##1"{Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}, Int64}) +precompile(Tuple{StaticArrayInterface.var"#rank_to_sortperm##0#rank_to_sortperm##1"{Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}, Int64}) +precompile(Tuple{Static.var"##49#50", Vararg{Any, 5}}) +precompile(Tuple{StrideArraysCore.var"##16#17", Any, Any, Any}) +precompile(Tuple{StrideArraysCore.var"##18#19", Any, Any, Any}) +precompile(Tuple{StrideArraysCore.var"##24#25", Any, Any}) +precompile(Tuple{StrideArraysCore.var"##26#27", Vararg{Any, 8}}) +precompile(Tuple{StrideArraysCore.var"##28#29", Vararg{Any, 8}}) +precompile(Tuple{StrideArraysCore.var"##30#31", Any, Any, Any}) +precompile(Tuple{StrideArraysCore.var"##32#33", Vararg{Any, 4}}) +precompile(Tuple{StrideArraysCore.var"##3#4", Vararg{Any, 4}}) +precompile(Tuple{StrideArraysCore.var"##45#46", Any, Any, Any}) +precompile(Tuple{StrideArraysCore.var"##5#6", Vararg{Any, 4}}) +precompile(Tuple{StrideArraysCore.var"##9#10", Any, Any, Any}) +precompile(Tuple{ThreadingUtilities.ThreadTask}) +precompile(Tuple{Type{Array{Base.Complex{Float64}, N} where N}, PythonCall.PyArray{Base.Complex{Float64}, 1, true, true, Base.Complex{Float64}}}) +precompile(Tuple{Type{Array{Base.Complex{Float64}, N} where N}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}}) +precompile(Tuple{Type{Array{Base.Complex{Float64}, N} where N}, PythonCall.PyArray{Base.Complex{Float64}, 3, true, false, Base.Complex{Float64}}}) +precompile(Tuple{Type{Array{Bool, N} where N}, PythonCall.PyArray{Bool, 1, true, true, Bool}}) +precompile(Tuple{Type{Array{Float64, 1}}, Array{Float64, 1}}) +precompile(Tuple{Type{Array{Float64, N} where N}, PythonCall.PyArray{Float64, 1, true, true, Float64}}) +precompile(Tuple{Type{Array{Float64, N} where N}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{Type{Array{Float64, N} where N}, PythonCall.PyArray{Float64, 2, true, true, Float64}}) +precompile(Tuple{Type{Array{Int64, N} where N}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{Type{Array{T, N} where N where T}, Array{Float64, 1}}) +precompile(Tuple{Type{Base.Fix{1, F, T} where T where F}, Type{Base.FilteringRF{F, T} where T where F}, Function}) +precompile(Tuple{Type{Base.Fix{1, F, T} where T where F}, typeof(tuple), Int64}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, KernelAbstractions.var"#67#68"{Tuple{}}, Base.UnitRange{Int64}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, PythonCall.Convert.var"#pyconvert_get_rules##0#pyconvert_get_rules##1", Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, PythonCall.Convert.var"#pyconvert_get_rules##6#pyconvert_get_rules##7", Base.Iterators.Filter{PythonCall.Convert.var"#pyconvert_get_rules##8#pyconvert_get_rules##9", Base.Iterators.Enumerate{Array{PythonCall.Convert.PyConvertRule, 1}}}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, SolpropJulia.var"#28#29"{Int64, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Tuple{Int64, Int64}}, Array{Base.UnitRange{Int64}, 1}}) +precompile(Tuple{Type{Base.Generator{I, F} where F where I}, typeof(Base.identity), Base.Iterators.Filter{PythonCall.Convert.var"#pyconvert_get_rules##4#pyconvert_get_rules##5", Array{PythonCall.Convert.PyConvertRule, 1}}}) +precompile(Tuple{Type{Base.Iterators.Filter{F, I} where I where F}, PythonCall.Convert.var"#pyconvert_get_rules##4#pyconvert_get_rules##5", Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{Type{Base.Iterators.Filter{F, I} where I where F}, PythonCall.Convert.var"#pyconvert_get_rules##8#pyconvert_get_rules##9", Base.Iterators.Enumerate{Array{PythonCall.Convert.PyConvertRule, 1}}}) +precompile(Tuple{Type{Base.Iterators.Flatten{I} where I}, Base.Generator{Array{PythonCall.Convert.PyConvertRule, 1}, PythonCall.Convert.var"#pyconvert_get_rules##0#pyconvert_get_rules##1"}}) +precompile(Tuple{Type{Base.IteratorsMD.CartesianIndex{N} where N}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{Type{Base.KeyError}, Char}) +precompile(Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Array{Function, 1}}) +precompile(Tuple{Type{Base.LinearIndices{N, R} where R<:Tuple{Vararg{Base.AbstractUnitRange{Int64}, N}} where N}, Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{Type{Base.Returns{V} where V}, Base.OneTo{Int64}}) +precompile(Tuple{Type{Base.Val{x} where x}, Tuple{Int64}}) +precompile(Tuple{Type{Base.Val{x} where x}, Tuple{Int64, Int64}}) +precompile(Tuple{Type{Base.Val{x} where x}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{Type{Int128}, UInt64}) +precompile(Tuple{Type{NamedTuple{(:array, :buffer, :copy), T} where T<:Tuple}, Tuple{Bool, Bool, Bool}}) +precompile(Tuple{Type{NamedTuple{(:copy,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:dense_buffer,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:dims, :init, :backend), T} where T<:Tuple}, Tuple{Int64, Float64, KernelAbstractions.POCL.POCLKernels.POCLBackend}}) +precompile(Tuple{Type{NamedTuple{(:dims, :init), T} where T<:Tuple}, Tuple{Int64, Float64}}) +precompile(Tuple{Type{NamedTuple{(:direct,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:heavy,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:init, :seed, :dims, :inclusive), T} where T<:Tuple}, Tuple{Float64, Float64, Int64, Bool}}) +precompile(Tuple{Type{NamedTuple{(:min,), T} where T<:Tuple}, Tuple{Int64}}) +precompile(Tuple{Type{NamedTuple{(:quadrature,), T} where T<:Tuple}, Tuple{Bool}}) +precompile(Tuple{Type{NamedTuple{(:use,), T} where T<:Tuple}, Tuple{Symbol}}) +precompile(Tuple{typeof(AcceleratedKernels.exact_neutral), typeof(Base.:(+)), Float64}) +precompile(Tuple{typeof(AcceleratedKernels.iswhole), Function}) +precompile(Tuple{typeof(ArrayInterface.ndims_index), Type{var"#s15"} where var"#s15"<:(AbstractArray{T, N} where N where T)}) +precompile(Tuple{typeof(ArrayInterface.ndims_shape), Type{var"#s15"} where var"#s15"<:(AbstractArray{T, N} where N where T)}) +precompile(Tuple{typeof(Artifacts.__artifact_str), Module, String, Base.SubString{String}, String, Base.Dict{String, Any}, Base.SHA1, Base.BinaryPlatforms.Platform, Base.Val{LazyArtifacts}}) +precompile(Tuple{typeof(Artifacts._artifact_str), Module, String, Base.SubString{String}, String, Base.Dict{String, Any}, Base.SHA1, Base.BinaryPlatforms.Platform, Base.Val{LazyArtifacts}}) +precompile(Tuple{typeof(Base.abs), Base.Complex{Float64}}) +precompile(Tuple{typeof(Base.abs), Int32}) +precompile(Tuple{typeof(Base.add_sum), Bool, Bool}) +precompile(Tuple{typeof(Base.add_sum), Float64, Float64}) +precompile(Tuple{typeof(Base._all), Base.Fix{2, typeof(Base.:(var"==")), Int64}, Array{Float64, 1}, Base.Colon}) +precompile(Tuple{typeof(Base.all), Function, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.all), Function, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base._any), Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Array{Float64, 1}, Base.Colon}) +precompile(Tuple{typeof(Base._any), Base.ComposedFunction{typeof(Base.:(!)), typeof(Base.iszero)}, Array{Float64, 2}, Base.Colon}) +precompile(Tuple{typeof(Base.any), Function, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.any), Function, Array{Float64, 2}}) +precompile(Tuple{typeof(Base._any_tuple), Base.var"#TupleOrBottom##0#TupleOrBottom##1", Bool, Type}) +precompile(Tuple{typeof(Base.append!), Array{Float64, 1}, NTuple{6, Float64}}) +precompile(Tuple{typeof(Base._array_for), Type{Function}, Array{PythonCall.Convert.PyConvertRule, 1}, Base.HasShape{1}}) +precompile(Tuple{typeof(Base._array_for), Type{PythonCall.Convert.PyConvertRule}, Array{PythonCall.Convert.PyConvertRule, 1}, Base.HasShape{1}}) +precompile(Tuple{typeof(Base._atexit), Int32}) # recompile +precompile(Tuple{typeof(Base.axes), Array{PythonCall.Convert.PyConvertRule, 1}, Int64}) +precompile(Tuple{typeof(Base.:(-)), Base.Complex{Bool}}) +precompile(Tuple{typeof(Base.:(>)), Base.VersionNumber, Base.VersionNumber}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Base.Complex{Float64}}, Array{Base.Complex{Float64}, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Array{Float64, 2}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.inv), Tuple{Array{Float64, 1}}}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(/)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Float64, Array{Float64, 1}}}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Float64}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(Base.:(/)), Tuple{Array{Float64, 2}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), Type{Int64}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Array{Base.Complex{Float64}, 1}, Float64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Array{Float64, 1}, Float64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(/)), Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(+)), Array{Int64, 1}, Int64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(/)), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Float64, Array{Float64, 1}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Float64, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.float), Tuple{Float64, Float64}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.identity), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.identity), Base.OneTo{Int64}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.inv), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Broadcast.broadcasted), typeof(Base.:(*)), Tuple{Int64}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{3}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Int64}) +precompile(Tuple{typeof(Base.Broadcast._broadcast_getindex), Float64, Int64}) +precompile(Tuple{typeof(Base.Broadcast.broadcast_shape), Tuple{Base.OneTo{Int64}}, Tuple{}}) +precompile(Tuple{typeof(Base.Broadcast.broadcast_shape), Tuple{}, Tuple{Base.OneTo{Int64}}}) +precompile(Tuple{typeof(Base.Broadcast._getindex), Tuple{Int64}, Int64}) +precompile(Tuple{typeof(Base.Broadcast.materialize!), Array{Base.Complex{Float64}, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Array{Base.Complex{Float64}, 1}, Float64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize!), Array{Float64, 1}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Array{Float64, 1}, Float64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Base.Complex{Float64}}, Tuple{Array{Base.Complex{Float64}, 1}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Float64}, Tuple{Array{Float64, 1}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Float64}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.inv), Tuple{Array{Float64, 1}}}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, Type{Float64}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(/)), Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Float64, Array{Float64, 1}}}, Int64}}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(*)), Tuple{Array{Base.Complex{Float64}, 1}, Float64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.:(+)), Tuple{Array{Int64, 1}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, Type{Float64}, Tuple{Array{Float64, 2}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, Type{Float64}, Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(Base.:(/)), Tuple{Array{Float64, 2}, Int64}}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(Base.:(/)), Tuple{Array{Float64, 2}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, Type{Int64}, Tuple{Tuple{Int64, Int64}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.float), Tuple{Tuple{Float64, Float64}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(*)), Tuple{Tuple{Int64}, Int64}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Float64, 1, Array{Float64, 1}, Tuple{Array{Int64, 1}}, false}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Array{Float64, 1}}}}) +precompile(Tuple{typeof(Base.Broadcast.materialize!), Base.SubArray{Int64, 1, Array{Int64, 1}, Tuple{Array{Int64, 1}}, false}, Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(Base.identity), Tuple{Base.OneTo{Int64}}}}) +precompile(Tuple{typeof(Base.Cartesian._nloops), Int64, Symbol, Bool, Symbol, Expr, Vararg{Expr}}) +precompile(Tuple{typeof(Base.__cat), Array{Bool, 1}, Tuple{Int64}, Tuple{Bool}, Array{Bool, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base.__cat), Array{Float64, 1}, Tuple{Int64}, Tuple{Bool}, Array{Float64, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base.__cat), Array{Int64, 1}, Tuple{Int64}, Tuple{Bool}, Array{Int64, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base.__cat_offset!), Array{Bool, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Bool, 1}, Bool}) +precompile(Tuple{typeof(Base.__cat_offset!), Array{Float64, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Float64, 1}, Float64}) +precompile(Tuple{typeof(Base.__cat_offset!), Array{Int64, 1}, Tuple{Int64}, Tuple{Bool}, Tuple{Int64}, Array{Int64, 1}, Int64}) +precompile(Tuple{typeof(Base.cat_similar), Array{Bool, 1}, Type{Bool}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.cat_similar), Array{Float64, 1}, Type{Float64}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.cat_similar), Array{Int64, 1}, Type{Int64}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.cat_size_shape), Tuple{Bool}, Array{Bool, 1}, Bool}) +precompile(Tuple{typeof(Base.cat_size_shape), Tuple{Bool}, Array{Float64, 1}, Float64}) +precompile(Tuple{typeof(Base.cat_size_shape), Tuple{Bool}, Array{Int64, 1}, Int64}) +precompile(Tuple{typeof(Base._cat_t), Base.Val{1}, Type{Bool}, Array{Bool, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base._cat_t), Base.Val{1}, Type{Float64}, Array{Float64, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base._cat_t), Base.Val{1}, Type{Int64}, Array{Int64, 1}, Vararg{Any}}) +precompile(Tuple{typeof(Base.cconvert), Type{Ptr{LLVM.API.JLOpaqueJuliaOJIT}}, LLVM.JuliaOJIT}) +precompile(Tuple{typeof(Base.cconvert), Type{Ptr{LLVM.API.LLVMOpaqueModule}}, LLVM.Module}) +precompile(Tuple{typeof(Base._check_valid_region), Int64}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Array{Base.UnitRange{Int64}, 1}, SolpropJulia.var"#28#29"{Int64, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Tuple{Int64, Int64}}}}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Base.Iterators.Filter{PythonCall.Convert.var"#pyconvert_get_rules##4#pyconvert_get_rules##5", Array{PythonCall.Convert.PyConvertRule, 1}}, typeof(Base.identity)}}) +precompile(Tuple{typeof(Base.collect), Base.Generator{Base.Iterators.Filter{PythonCall.Convert.var"#pyconvert_get_rules##8#pyconvert_get_rules##9", Base.Iterators.Enumerate{Array{PythonCall.Convert.PyConvertRule, 1}}}, PythonCall.Convert.var"#pyconvert_get_rules##6#pyconvert_get_rules##7"}}) +precompile(Tuple{typeof(Base.collect), Base.Iterators.Flatten{Base.Generator{Array{PythonCall.Convert.PyConvertRule, 1}, PythonCall.Convert.var"#pyconvert_get_rules##0#pyconvert_get_rules##1"}}}) +precompile(Tuple{typeof(Base.Compiler.add_edges_impl), Array{Any, 1}, Base.Compiler.ConstCallInfo}) # recompile +precompile(Tuple{typeof(Base.Compiler.add_edges_impl), Array{Any, 1}, Base.Compiler.MethodMatchInfo}) # recompile +precompile(Tuple{typeof(Base.Compiler.compute_inlining_cost), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceResult, Base.Compiler.OptimizationResult}) +precompile(Tuple{typeof(Base.Compiler.doworkloop), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceState}) +precompile(Tuple{typeof(Base.Compiler.finish!), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceState, UInt64, UInt64}) +precompile(Tuple{typeof(Base.Compiler.finish_nocycle), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceState, UInt64}) +precompile(Tuple{typeof(Base.Compiler.instanceof_tfunc), Any, Bool, Core.PartialStruct}) +precompile(Tuple{typeof(Base.Compiler.optimize), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.OptimizationState{GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}}, Base.Compiler.InferenceResult}) +precompile(Tuple{typeof(Base.Compiler.typeinf_code), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Core.MethodInstance, Bool}) +precompile(Tuple{typeof(Base.Compiler.typeinf_local), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Base.Compiler.InferenceState, Base.Compiler.CurrentState}) +precompile(Tuple{typeof(Base.convert), Type{Number}, Int64}) +precompile(Tuple{typeof(Base.convert), Type{Ptr{Nothing}}, Ptr{Nothing}}) +precompile(Tuple{typeof(Base.copy!), Array{Any, 1}, Array{Any, 1}}) +precompile(Tuple{typeof(Base.copyto!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(Base.copyto!), Array{Float64, 1}, Array{Float64, 1}}) +precompile(Tuple{typeof(Base.copyto!), Array{Float64, 2}, Array{Float64, 2}}) +precompile(Tuple{typeof(Base.copyto!), Array{Int64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base._cshp), Int64, Tuple{Bool}, Tuple{}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.cumsum), Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.cumsum), Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.deleteat!), Array{Symbol, 1}, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.eachindex), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.eachindex), Core.SimpleVector}) +precompile(Tuple{typeof(Base.:(*)), FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(Base.findfirst), Function, NTuple{7, Symbol}}) +precompile(Tuple{typeof(Base.findfirst), Function, Tuple{Int64}}) +precompile(Tuple{typeof(Base.findfirst), Function, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.findfirst), Function, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base._findfirst_rec), Base.Fix{2, typeof(Base.:(var"==")), Int64}, Int64, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base._findfirst_rec), Base.Fix{2, typeof(Base.:(var"==")), Symbol}, Int64, NTuple{7, Symbol}}) +precompile(Tuple{typeof(Base.:(>)), Float64, Float64}) +precompile(Tuple{typeof(Base.:(>=)), Float64, Float64}) +precompile(Tuple{typeof(Base.get), Base.IOStream, Symbol, Bool}) +precompile(Tuple{typeof(Base.getindex), Array{Bool, 1}, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.getindex), Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.getindex), Array{Float64, 1}, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.getindex), Array{Float64, 1}, Int64}) +precompile(Tuple{typeof(Base.getindex), Array{Float64, 2}, Int64, Int64}) +precompile(Tuple{typeof(Base.getindex), Array{Int64, 1}, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.getindex), Array{PythonCall.Convert.PyConvertRule, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.getindex), Array{PythonCall.Convert.PyConvertRule, 1}, Int64}) +precompile(Tuple{typeof(Base.getindex), Base.RefValue{Any}}) +precompile(Tuple{typeof(Base.getindex), Core.SimpleVector, Base.UnitRange{Int64}}) +precompile(Tuple{typeof(Base.getindex), Type{Int64}, Int64, Int64, Int64, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(Base.getindex), Type{Union{Nothing, LLVM.Metadata}}, LLVM.DIFile, LLVM.MDString, Nothing, Nothing, Vararg{Nothing}}) +precompile(Tuple{typeof(Base.getproperty), AcceleratedKernels.AccOp{Float64, typeof(Base.:(+))}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), AcceleratedKernels.CPUThreads.Partitioned, Symbol}) +precompile(Tuple{typeof(Base.getproperty), AcceleratedKernels.OptionalOp{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), AcceleratedKernels.OptionalOp{typeof(Base.:(+))}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{AcceleratedKernels.OptionalOp{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{AcceleratedKernels.OptionalOp{typeof(Base.:(+))}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.var"#foreach##0#foreach##1"{SolpropJulia.var"#clear_plasma!##0#clear_plasma!##1"}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.var"#foreach##0#foreach##1"{SolpropJulia.var"#reset_work!##0#reset_work!##1"}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{Base.var"#foreach##2#foreach##3"{typeof(Base.copyto!)}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{PythonCall.Utils.var"#explode_union##0#explode_union##1"}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{typeof(Base.Checked.checked_mul)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.BottomRF{typeof(Base.GMP.MPZ.add!)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{1}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{2}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, Nothing, typeof(Base.:(>=)), Tuple{Static.StaticInt{3}, Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.IteratorsMD.CartesianIndex{3}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.IteratorsMD.CartesianIndices{0, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.MappingRF{typeof(Base.identity), typeof(Base.mul_prod)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Base.MappingRF{typeof(Base.:(-)), typeof(Base.max)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), KernelAbstractions.Kernel{KernelAbstractions.POCL.POCLKernels.POCLBackend, KernelAbstractions.NDIteration.DynamicSize, KernelAbstractions.NDIteration.DynamicSize, typeof(KernelAbstractions.POCL.POCLKernels.gpu_fill_kernel)}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Markdown.MD, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:selected, :matrix, :synthesised, :energy), Tuple{Array{Int64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:selected, :matrix, :synthesised, :energy), Tuple{Array{Int64, 1}, Nothing, Nothing, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:signal, :weighted, :weight, :inverse, :rows, :electric, :magnetic, :power, :flux, :host_power, :host_flux), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:signal, :weighted, :weight, :inverse, :rows, :electric, :magnetic, :power, :flux, :host_power, :host_flux), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##2#rk4!##3"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##4#rk4!##5"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##6#rk4!##7"{Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#weighted_norm##0#weighted_norm##1"{Array{Base.Complex{Float64}, 2}, Float64, Float64, Float64, Array{Bool, 1}, Array{Float64, 1}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#combine!##4#combine!##5"{Int64, Tuple{Float64, Float64, Float64}, NTuple{7, Float64}, NTuple{7, Float64}, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#band_alarm##0#band_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#quadrature_alarm##0#quadrature_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 3, (1, 2, 3), Tuple{Int64, Int64, Int64}, Tuple{Nothing, Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 3, (1, 2, 3), Tuple{Int64, Int64, Int64}, Tuple{Nothing, Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#column_energy##0#column_energy##1"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##0#edge_energy##1"{Float64, Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##2#edge_energy##3"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#plasma_columns!##0#plasma_columns!##1"{Array{Float64, 2}, Int64, Float64, Float64, Float64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#population_columns!##0#population_columns!##1"{Array{Float64, 2}, Int64, Float64, Int64, Int64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#absorber!##0#absorber!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#add_plasma_spectra!##0#add_plasma_spectra!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##2#analytic_signal!##3"{Array{Base.Complex{Float64}, 2}, Float64, Int64, Float64, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#collar_factor##0#collar_factor##1"{Array{Float64, 1}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#columns_into!##0#columns_into!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#convolve!##0#convolve!##1"{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#finish_band!##0#finish_band!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#finish_source!##0#finish_source!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_propagators!##0#free_propagators!##1"{Float64, Bool, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#gather_columns!##0#gather_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Int64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#integrate_samples!##0#integrate_samples!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Float64, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#mask!##0#mask!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#material_stage!##0#material_stage!##1"{Int64, Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_envelope!##0#nonlinear_envelope!##1"{Array{Float64, 2}, Bool, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Float64, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#path_propagators!##0#path_propagators!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##0#plasma_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##2#plasma_samples!##3"{Array{Float64, 2}, Float64, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##4#plasma_samples!##5"{Array{Float64, 2}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Base.SubArray{Base.Complex{Float64}, 2, Array{Base.Complex{Float64}, 3}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Int64}, true}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##0#population_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##2#population_samples!##3"{Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##4#population_samples!##5"{Array{Float64, 2}, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##6#population_samples!##7"{Float64, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##0#poynting!##1"{Base.Complex{Float64}, Float64, Float64, Int64, Bool, Array{Float64, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##2#poynting!##3"{Float64, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##4#poynting!##5"{Float64, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#propagators!##2#propagators!##3"{NTuple{7, Float64}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Int64, Bool, Array{Float64, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Float64, 2}, Int64, Bool, Array{Float64, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_products!##0#raman_products!##1"{Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#rk4!##0#rk4!##1"{Float64, Float64, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#scatter!##0#scatter!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#scatter_columns!##0#scatter_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64, Array{Int64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##8#source_free!##9"{Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##0#source_spectral!##1"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##10#source_spectral!##11"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##2#source_spectral!##3"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##4#source_spectral!##5"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##6#source_spectral!##7"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##8#source_spectral!##9"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spectral_plasma!##2#spectral_plasma!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##2#split_free!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Float64, 2}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#trial!##2#trial!##3"{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, NTuple{6, Float64}, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#trial!##4#trial!##5"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Int64, Int64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#occupancy##0#occupancy##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Int32, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Int32}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#rowsum!##0#rowsum!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}, SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Int64, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#rowsum!##0#rowsum!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}, SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Float64, 2}, Array{Float64, 1}, Int64, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), Polyester.BatchClosure{SolpropJulia.var"#transform_all!##0#transform_all!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, typeof(SolpropJulia.transform_block!), SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Tuple{StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}, Tuple{StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}}, false, Tuple{}}, Symbol}) +precompile(Tuple{typeof(Base.getproperty), PythonCall.Convert.PyConvertRule, Symbol}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Any}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Array{Any, 1}}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Array{Int64, 1}}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Base.Dict{Symbol, Any}}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Bool}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Int64}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{String}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{Tuple{Vararg{Symbol}}}}) +precompile(Tuple{typeof(Base.get!), Type{Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Base.Dict{Type, Base.Dict{Ptr{PythonCall.C.PyObject}, Array{Function, 1}}}, Type{UInt64}}) +precompile(Tuple{typeof(Base.ifelse), Bool, Base.Missing, Nothing}) +precompile(Tuple{typeof(Base.indexed_iterate), Pair{String, Bool}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Pair{String, Bool}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int64, typeof(DataType)}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Int64, typeof(DataType)}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Nothing, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Polyester.CombineIndices, Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Polyester.CombineIndices, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Polyester.NoLoop, Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Polyester.NoLoop, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Static.StaticInt{1}, Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Static.StaticInt{1}, Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Tuple{}, Base._InitialValue}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{Tuple{}, Base._InitialValue}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.identity), AcceleratedKernels.AccOp{Float64, typeof(Base.:(+))}}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.identity), AcceleratedKernels.AccOp{Float64, typeof(Base.:(+))}}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.identity), AcceleratedKernels.OptionalOp{typeof(Base.:(+))}}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.identity), AcceleratedKernels.OptionalOp{typeof(Base.:(+))}}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.:(+)), Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(Base.:(+)), Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(SolpropJulia.transform_block!), Nothing}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(SolpropJulia.transform_block!), Nothing}, Int64, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(SolpropJulia.trial!), Tuple{typeof(DataType), typeof(DataType)}}, Int64}) +precompile(Tuple{typeof(Base.indexed_iterate), Tuple{typeof(SolpropJulia.trial!), Tuple{typeof(DataType), typeof(DataType)}}, Int64, Int64}) +precompile(Tuple{typeof(Base.in), Symbol, NTuple{7, Symbol}}) +precompile(Tuple{typeof(Base.:(+)), Int128, Int64}) +precompile(Tuple{typeof(Base.:(-)), Int128, Int64}) +precompile(Tuple{typeof(Base.:(*)), Int64, Static.StaticInt{1}}) +precompile(Tuple{typeof(Base.:(+)), Int64, Static.StaticInt{1}}) +precompile(Tuple{typeof(Base.:(-)), Int64, Static.StaticInt{1}}) +precompile(Tuple{typeof(Base.:(<)), Int64, Static.StaticInt{1}}) +precompile(Tuple{typeof(Base.:(<)), Int64, Static.StaticInt{2}}) +precompile(Tuple{typeof(Base.:(<)), Int64, Static.StaticInt{3}}) +precompile(Tuple{typeof(Base.:(-)), Int64, UInt32}) +precompile(Tuple{typeof(Base.:(*)), Int64, UInt64}) +precompile(Tuple{typeof(Base._in_tuple), Int64, Tuple, Bool}) +precompile(Tuple{typeof(Base._in_tuple), Type, Tuple, Bool}) +precompile(Tuple{typeof(Base.in), Type, NTuple{11, typeof(DataType)}}) +precompile(Tuple{typeof(Base.in), Type, NTuple{12, typeof(DataType)}}) +precompile(Tuple{typeof(Base.in), Type, NTuple{16, typeof(DataType)}}) +precompile(Tuple{typeof(Base.in), Type, NTuple{4, typeof(DataType)}}) +precompile(Tuple{typeof(Base.isempty), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.ispow2), Int64}) +precompile(Tuple{typeof(Base.issorted), Array{String, 1}, Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}}) +precompile(Tuple{typeof(Base.iterate), Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{typeof(Base.iterate), Array{PythonCall.Convert.PyConvertRule, 1}, Int64}) +precompile(Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, KernelAbstractions.var"#67#68"{Tuple{}}}}) +precompile(Tuple{typeof(Base.iterate), Base.Generator{Base.UnitRange{Int64}, KernelAbstractions.var"#67#68"{Tuple{}}}, Int64}) +precompile(Tuple{typeof(Base.iterate), Base.Iterators.Enumerate{Core.SimpleVector}}) +precompile(Tuple{typeof(Base.iterate), Base.Iterators.Enumerate{Core.SimpleVector}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.Iterators.enumerate), Array{PythonCall.Convert.PyConvertRule, 1}}) +precompile(Tuple{typeof(Base.Iterators.enumerate), Core.SimpleVector}) +precompile(Tuple{typeof(Base.JuliaSyntax.core_parser_hook), Core.SimpleVector, String, Int64, Int64, Symbol}) +precompile(Tuple{typeof(Base.lastindex), Array{Bool, 1}}) +precompile(Tuple{typeof(Base.lastindex), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.last), Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.last), Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.length), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.Libc.Libdl.dlopen), FFTW.FakeLazyLibrary}) +precompile(Tuple{typeof(Base.Libc.Libdl.dlsym), Ptr{Nothing}, Symbol}) +precompile(Tuple{typeof(Base._mapreduce), typeof(Base.abs), typeof(Base.max), Base.IndexLinear, Array{Base.Complex{Float64}, 1}}) +precompile(Tuple{typeof(Base.map), SolpropJulia.var"#adams_workspace##3#adams_workspace##4"{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}}) +precompile(Tuple{typeof(Base.map), StrideArraysCore.var"#12#13"{Tuple{Int64, Int64, Int64}}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.map), StrideArraysCore.var"#12#13"{Tuple{Int64, Int64}}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.map), StrideArraysCore.var"#12#13"{Tuple{Int64}}, Tuple{Int64}}) +precompile(Tuple{typeof(Base.Math._hypot), Float64, Float64}) +precompile(Tuple{typeof(Base.Math.hypot), Float64, Float64}) +precompile(Tuple{typeof(Base.maximum), Function, Array{Base.Complex{Float64}, 1}}) +precompile(Tuple{typeof(Base.maybeview), Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.maybeview), Array{Int64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, NamedTuple{(:spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :coarse_rate, :nc, :embedded), Tuple{Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Int64, Bool}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, NamedTuple{(:spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :coarse_rate, :nc), Tuple{Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Float64, 1}, Int64}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64}}, NamedTuple{(:crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:dims,), Tuple{Int64}}, Base.Pairs{Symbol, Float64, Nothing, NamedTuple{(:init,), Tuple{Float64}}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:dims,), Tuple{Int64}}, Base.Pairs{Symbol, Union{}, Nothing, NamedTuple{(), Tuple{}}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}}}, NamedTuple{(:weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing}}, NamedTuple{(:forward, :inverse), Tuple{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, Base.Pairs{Symbol, Float64, Nothing, NamedTuple{(:init,), Tuple{Float64}}}}) +precompile(Tuple{typeof(Base.merge), NamedTuple{(), Tuple{}}, Base.Pairs{Symbol, Real, Nothing, NamedTuple{(:dims, :init), Tuple{Int64, Float64}}}}) +precompile(Tuple{typeof(Base.mod), Int64, Type{Int64}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#flatten_tuples##0#flatten_tuples##1"{Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#flatten_tuples##0#flatten_tuples##1"{Tuple{Static.StaticInt{1}, Static.StaticInt{2}}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#flatten_tuples##0#flatten_tuples##1"{Tuple{Tuple{Static.StaticInt{1}}, Tuple{Static.StaticInt{1}}, Tuple{Static.StaticInt{1}}}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#flatten_tuples##0#flatten_tuples##1"{Tuple{Tuple{Static.StaticInt{1}}, Tuple{Static.StaticInt{1}}}, Tuple{Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_index)}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_index)}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_shape)}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(ArrayInterface.ndims_shape)}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(StaticArrayInterface.is_splat_index)}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), ArrayInterface.var"#map_tuple_type##0#map_tuple_type##1"{typeof(StaticArrayInterface.is_splat_index)}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), Base.Fix{1, typeof(tuple), Int64}, Base.Val{1}}) +precompile(Tuple{typeof(Base.ntuple), Base.Iterators.var"#IteratorEltype##0#IteratorEltype##1"{Tuple{Array{PythonCall.Py, 1}, Array{Array{String, 1}, 1}}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), Base.Iterators.var"#IteratorSize##0#IteratorSize##1"{Tuple{Array{PythonCall.Py, 1}, Array{Array{String, 1}, 1}}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), Base.Iterators.var"#IteratorSize##2#IteratorSize##3"{Tuple{Array{Tuple{Int64, Int64}, 1}, Base.UnitRange{Int64}}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), Base.Iterators.var"#IteratorSize##2#IteratorSize##3"{Tuple{Base.UnitRange{Int64}, Base.UnitRange{Int64}}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), Base.Returns{Base.OneTo{Int64}}, Base.Val{1}}) +precompile(Tuple{typeof(Base.ntuple), Base.Returns{Base.OneTo{Int64}}, Base.Val{2}}) +precompile(Tuple{typeof(Base.ntuple), Base.Returns{Bool}, Base.Val{3}}) +precompile(Tuple{typeof(Base.ntuple), Base.var"#__cat_offset1!##2#__cat_offset1!##3"{Tuple{Bool}, Tuple{Int64}, Float64}, Int64}) +precompile(Tuple{typeof(Base.ntuple), PythonCall.JlWrap.Cjl.var"#11#12", Int64}) +precompile(Tuple{typeof(Base.ntuple), SolpropJulia.var"#adams_workspace##1#adams_workspace##2", Int64}) +precompile(Tuple{typeof(Base.ntuple), SolpropJulia.var"#block_view##0#block_view##1", Int64}) +precompile(Tuple{typeof(Base.ntuple), StaticArrayInterface.var"#_accum_dims##0#_accum_dims##1"{Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), StaticArrayInterface.var"#_accum_dims##0#_accum_dims##1"{Tuple{Int64, Int64}, Tuple{Int64, Int64}}, Int64}) +precompile(Tuple{typeof(Base.ntuple), StaticArrayInterface.var"#map_indices_info##0#map_indices_info##1"{Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}, Static.StaticInt{3}}) +precompile(Tuple{typeof(Base.ntuple), StaticArrayInterface.var"#map_indices_info##0#map_indices_info##1"{Tuple{Int64, Int64}, Tuple{Int64, Int64}}, Static.StaticInt{2}}) +precompile(Tuple{typeof(Base.Order.lt), Base.Order.ReverseOrdering{Base.Order.ForwardOrdering}, Tuple{PythonCall.PyConvertPriority, Int64}, Tuple{PythonCall.PyConvertPriority, Int64}}) +precompile(Tuple{typeof(Base.pairs), NamedTuple{(:dims, :init), Tuple{Int64, Float64}}}) +precompile(Tuple{typeof(Base.pairs), NamedTuple{(:init,), Tuple{Float64}}}) +precompile(Tuple{typeof(Base.pointer), PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(Base.pointer), PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(Base.pointer), PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(Base._prechecked_iterate), Base.OneTo{Int64}, Int64}) +precompile(Tuple{typeof(Base.print), Base.GenericIOBuffer{Memory{UInt8}}, PythonCall.Py}) +precompile(Tuple{typeof(Base.prod), Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.promote), Float64, Float64}) +precompile(Tuple{typeof(Base.reinterpret), Type{Int64}, Float64}) +precompile(Tuple{typeof(Base.reshape), Array{Base.Complex{Float64}, 2}, Int64, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(Base.setindex!), Array{Function, 1}, Function, Int64}) +precompile(Tuple{typeof(Base.setindex!), Array{PythonCall.Convert.PyConvertRule, 1}, PythonCall.Convert.PyConvertRule, Int64}) +precompile(Tuple{typeof(Base.setindex!), Array{Symbol, 1}, Symbol, Int64}) +precompile(Tuple{typeof(Base.setindex), Tuple{Int64, Int64, Int64}, Int64, Int64}) +precompile(Tuple{typeof(Base._setindex), Vararg{Int64, 5}}) +precompile(Tuple{typeof(Base.similar), Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(Base.size), Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(Base.size), Array{Base.Complex{Float64}, 3}, Int64}) +precompile(Tuple{typeof(Base.size), Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(Base.sizeof), Symbol}) +precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:dims, :init, :backend), Tuple{Int64, Float64, KernelAbstractions.POCL.POCLKernels.POCLBackend}}, Type{NamedTuple{(:backend, :workspace), T} where T<:Tuple}}) +precompile(Tuple{typeof(Base.structdiff), NamedTuple{(:dims, :init), Tuple{Int64, Float64}}, Type{NamedTuple{(:dims,), T} where T<:Tuple}}) +precompile(Tuple{typeof(Base.sum), Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.sum), Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{13, Symbol}}) # recompile +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{17, Symbol}}) +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{35, Symbol}}) +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{44, Symbol}}) +precompile(Tuple{typeof(Base.sym_in), Symbol, NTuple{47, Symbol}}) +precompile(Tuple{typeof(Base.:(!=)), UInt32, UInt32}) +precompile(Tuple{typeof(Base.:(>)), UInt32, UInt32}) +precompile(Tuple{typeof(Base.:(<=)), UInt32, UInt8}) +precompile(Tuple{typeof(Base.:(>)), UInt8, UInt8}) +precompile(Tuple{typeof(Base.unsafe_convert), Type{Ptr{LLVM.API.LLVMOpaqueModule}}, LLVM.Module}) +precompile(Tuple{typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{UInt8}, Int64}) +precompile(Tuple{typeof(Base.unsafe_wrap), Type{Array{T, N} where N where T}, Ptr{UInt8}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Base.:(var"==")), Base.OneTo{Int64}}) +precompile(Tuple{typeof(Base.:(var"==")), Int64}) +precompile(Tuple{typeof(Base.:(var"==")), JSON.JSONTypes.T, JSON.JSONTypes.T}) +precompile(Tuple{typeof(Base.:(var"==")), Method, Method}) +precompile(Tuple{typeof(Base.:(var"==")), Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(Base.:(var"==")), TypeVar, TypeVar}) +precompile(Tuple{typeof(Base.vcat), Array{Bool, 1}, Bool}) +precompile(Tuple{typeof(Base.vcat), Array{Float64, 1}, Float64}) +precompile(Tuple{typeof(Base.vcat), Array{Int64, 1}, Int64}) +precompile(Tuple{typeof(Base.zero), Array{Float64, 1}}) +precompile(Tuple{typeof(Base.zeros), Int64}) +precompile(Tuple{typeof(Base.zeros), Int64, Int64}) +precompile(Tuple{typeof(Base.zeros), Type{Float64}, Int64, Int64}) +precompile(Tuple{typeof(BitTwiddlingConvenienceFunctions.nextpow2), Int64}) +precompile(Tuple{typeof(CompilerCaching.get_codeinfos), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Core.CodeInstance}) +precompile(Tuple{typeof(CompilerCaching.with_fresh_inference_cache), CompilerCaching.var"#infer_source!##0#infer_source!##1"{Core.MethodInstance}, GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}}) +precompile(Tuple{typeof(Core.checked_dims), Int64, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(Core._checked_mul_dims), Int64, Int64, Int64}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:by, :rev), Tuple{PythonCall.Convert.var"#_pyconvert_get_rules##19#_pyconvert_get_rules##20", Bool}}, typeof(Base.sort), Base.OneTo{Int64}}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:compiled,), Tuple{Base.Dict{Any, Any}}}, typeof(GPUCompiler.check_ir), GPUCompiler.CompilerJob{GPUCompiler.SPIRVCompilerTarget, KernelAbstractions.POCL.OpenCLCompilerParams}, LLVM.Module, GPUCompiler.Relocations}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:flags, :num_threads), Tuple{UInt32, Int64}}, typeof(AbstractFFTs.plan_brfft), Array{Base.Complex{Float64}, 2}, Int64, Int64}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:interp,), Tuple{GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}}}, typeof(GPUCompiler.typeinf_type), Core.MethodInstance}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:modes, :nodes, :synthesis), Tuple{Int64, Int64, Array{Float64, 2}}}, typeof(SolpropJulia.raman_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}, Int64, Int64}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:name,), Tuple{Nothing}}, typeof(KernelAbstractions.POCL.compiler_config), KernelAbstractions.POCL.nanoOpenCL.Device}) # recompile +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:threads, :batch), Tuple{Int64, Int64}}, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Function, Array{Base.Complex{Float64}, 3}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:threads,), Tuple{Int64}}, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Function, Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:threads,), Tuple{Int64}}, typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Function, Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(FFTW.fftw_init_check)}) +precompile(Tuple{typeof(FFTW.maybe_destroy_plan), FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}) +precompile(Tuple{typeof(FFTW.maybe_destroy_plan), FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}) +precompile(Tuple{typeof(FFTW.maybe_destroy_plan), FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}) +precompile(Tuple{typeof(FFTW.maybe_destroy_plan), FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}) +precompile(Tuple{typeof(GPUCompiler.build_runtime), GPUCompiler.CompilerJob{T, P} where P where T, GPUCompiler.CompilerConfig{GPUCompiler.SPIRVCompilerTarget, KernelAbstractions.POCL.OpenCLCompilerParams}}) +precompile(Tuple{typeof(GPUCompiler.compile), Symbol, GPUCompiler.CompilerJob{T, P} where P where T}) +precompile(Tuple{typeof(GPUCompiler.drive_inference!), GPUCompiler.GPUInterpreter{Base.Compiler.CachedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{CompilerCaching.StackedMethodTable{Base.Compiler.InternalMethodTable}}}}}}}, Core.MethodInstance}) +precompile(Tuple{typeof(GPUCompiler.finish_ir!), GPUCompiler.CompilerJob{GPUCompiler.SPIRVCompilerTarget, KernelAbstractions.POCL.OpenCLCompilerParams}, LLVM.Module, LLVM.Function}) +precompile(Tuple{typeof(GPUCompiler.llvm_datalayout), GPUCompiler.SPIRVCompilerTarget}) +precompile(Tuple{typeof(GPUCompiler.mcgen), GPUCompiler.CompilerJob{GPUCompiler.SPIRVCompilerTarget, KernelAbstractions.POCL.OpenCLCompilerParams}, LLVM.Module, LLVM.API.LLVMCodeGenFileType}) +precompile(Tuple{typeof(GPUCompiler.stack_method_tables), UInt64, Core.MethodTable}) +precompile(Tuple{typeof(JLLWrappers.get_julia_libpaths)}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type{Base.Complex{Float64}}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type{Base.Complex{Float64}}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type{Float64}, Tuple{Int64}}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type{Float64}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type, Int64, Int64}) +precompile(Tuple{typeof(KernelInterface.zeros), KernelAbstractions.POCL.POCLKernels.POCLBackend, Type, Int64, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(LLVM.api_cstring_arg), Any}) +precompile(Tuple{typeof(LLVM.check_library), LLVM.Library, LLVM.LLVMSymbol}) +precompile(Tuple{typeof(LLVM.check_library), LLVM.Library, LLVM.Module, String}) +precompile(Tuple{typeof(LLVM.getprop), LLVM.Function, Base.Val{:name}}) +precompile(Tuple{typeof(LLVM.getprop), LLVM.Function, Base.Val{:uses}}) +precompile(Tuple{typeof(pocl_standalone_jll.is_available)}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Base.Complex{Float64}, 2}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Base.Complex{Float64}, 3}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Float64, 1}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Float64, 2}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Int32, 2}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Tuple{Float64, Float64}, 1}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Array{Tuple{Float64, Float64, Float64}, 1}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.ReshapedArray{Float64, 2, Base.ReinterpretArray{Float64, 2, Base.Complex{Float64}, Array{Base.Complex{Float64}, 2}, false}, Tuple{}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.ReshapedArray{Float64, 2, Base.ReinterpretArray{Float64, 2, Base.Complex{Float64}, Base.SubArray{Base.Complex{Float64}, 2, Array{Base.Complex{Float64}, 2}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.UnitRange{Int64}}, true}, false}, Tuple{}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.SubArray{Float64, 2, Array{Float64, 2}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.UnitRange{Int64}}, true}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Base.SubArray{Float64, 2, Array{Float64, 2}, Tuple{Base.UnitRange{Int64}, Base.Slice{Base.OneTo{Int64}}}, false}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Bool}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Float64}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Int64}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Polyester.CombineIndices}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Polyester.NoLoop}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#absorber!##0#absorber!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#add_plasma_spectra!##0#add_plasma_spectra!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Int64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Float64, 2}, Array{Float64, 1}, Int64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#analytic_signal!##2#analytic_signal!##3"{Array{Base.Complex{Float64}, 2}, Float64, Int64, Float64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#band_alarm##0#band_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#collar_factor##0#collar_factor##1"{Array{Float64, 1}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#column_energy##0#column_energy##1"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##0#edge_energy##1"{Float64, Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##2#edge_energy##3"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#columns_into!##0#columns_into!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#combine!##4#combine!##5"{Int64, Tuple{Float64, Float64, Float64}, NTuple{7, Float64}, NTuple{7, Float64}, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#convolve!##0#convolve!##1"{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#finish_band!##0#finish_band!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#finish_source!##0#finish_source!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#free_propagators!##0#free_propagators!##1"{Float64, Bool, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#gather_columns!##0#gather_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Int64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#integrate_samples!##0#integrate_samples!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Float64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#mask!##0#mask!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#material_stage!##0#material_stage!##1"{Int64, Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_envelope!##0#nonlinear_envelope!##1"{Array{Float64, 2}, Bool, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Float64, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#path_propagators!##0#path_propagators!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#plasma_columns!##0#plasma_columns!##1"{Array{Float64, 2}, Int64, Float64, Float64, Float64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#plasma_samples!##0#plasma_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#plasma_samples!##2#plasma_samples!##3"{Array{Float64, 2}, Float64, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#plasma_samples!##4#plasma_samples!##5"{Array{Float64, 2}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Base.SubArray{Base.Complex{Float64}, 2, Array{Base.Complex{Float64}, 3}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Int64}, true}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_columns!##0#population_columns!##1"{Array{Float64, 2}, Int64, Float64, Int64, Int64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_samples!##0#population_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_samples!##2#population_samples!##3"{Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_samples!##4#population_samples!##5"{Array{Float64, 2}, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#population_samples!##6#population_samples!##7"{Float64, Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#poynting!##0#poynting!##1"{Base.Complex{Float64}, Float64, Float64, Int64, Bool, Array{Float64, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#poynting!##2#poynting!##3"{Float64, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#poynting!##4#poynting!##5"{Float64, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#propagators!##2#propagators!##3"{NTuple{7, Float64}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#quadrature_alarm##0#quadrature_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Int64, Bool, Array{Float64, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Float64, 2}, Int64, Bool, Array{Float64, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#raman_products!##0#raman_products!##1"{Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#rk4!##0#rk4!##1"{Float64, Float64, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#rk4!##2#rk4!##3"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#rk4!##4#rk4!##5"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#rk4!##6#rk4!##7"{Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#scatter!##0#scatter!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#scatter_columns!##0#scatter_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64, Array{Int64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_free!##8#source_free!##9"{Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##0#source_spectral!##1"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##10#source_spectral!##11"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##2#source_spectral!##3"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##4#source_spectral!##5"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##6#source_spectral!##7"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#source_spectral!##8#source_spectral!##9"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#spectral_plasma!##2#spectral_plasma!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_free!##2#split_free!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#trial!##2#trial!##3"{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, NTuple{6, Float64}, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#trial!##4#trial!##5"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Int64, Int64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{SolpropJulia.var"#weighted_norm##0#weighted_norm##1"{Array{Base.Complex{Float64}, 2}, Float64, Float64, Float64, Array{Bool, 1}, Array{Float64, 1}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Static.StaticInt{1}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Tuple{Float64, Float64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{Tuple{Float64, Float64}}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{typeof(Base.:(+))}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.add_var!), Expr, Expr, Expr, Type{typeof(SolpropJulia.transform_block!)}, Symbol, Symbol, Int64}) +precompile(Tuple{typeof(Polyester.combine), Polyester.CombineIndices, Polyester.NoLoop, Int64}) +precompile(Tuple{typeof(PythonCall.Convert.pyconvert_isunconverted), PythonCall.Convert.Unconverted}) +precompile(Tuple{typeof(PythonCall.Convert.pyconvert_result), Type{Any}, Int64}) +precompile(Tuple{typeof(PythonCall.Core.pycallargs), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.Core.pytuple_fromiter), Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.JlWrap.Cjl._pyjl_get_buffer_impl), Ptr{PythonCall.C.PyObject}, Ptr{PythonCall.C.Py_buffer}, Int32, Array{Bool, 1}, typeof(PythonCall.JlWrap.pyjlarray_buffer_info)}) +precompile(Tuple{typeof(PythonCall.JlWrap.Cjl._pyjl_get_buffer_impl), Ptr{PythonCall.C.PyObject}, Ptr{PythonCall.C.Py_buffer}, Int32, Array{Float64, 1}, typeof(PythonCall.JlWrap.pyjlarray_buffer_info)}) +precompile(Tuple{typeof(PythonCall.JlWrap.Cjl._pyjl_get_buffer_impl), Ptr{PythonCall.C.PyObject}, Ptr{PythonCall.C.Py_buffer}, Int32, Array{Float64, 2}, typeof(PythonCall.JlWrap.pyjlarray_buffer_info)}) +precompile(Tuple{typeof(PythonCall.JlWrap.Cjl._pyjl_get_buffer_impl), Ptr{PythonCall.C.PyObject}, Ptr{PythonCall.C.Py_buffer}, Int32, Array{Int64, 1}, typeof(PythonCall.JlWrap.pyjlarray_buffer_info)}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), Main.var"#2#3", PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call_nogil), typeof(SolpropJulia.commit!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call_nogil), typeof(SolpropJulia.march_run!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call_nogil), typeof(SolpropJulia.rk4!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call_nogil), typeof(SolpropJulia.trial!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_edge!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_monitor!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_poynting!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_spatial!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_stage_constants!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.bind_stage_table!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.clenshaw_points!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.column_energy), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.configure_march!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.configure_stages_at!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.copy_state!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.create), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.device_name), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.loaded_digest), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.load!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.march_run!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.node_energy), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.occupancy), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.population_snapshot), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.poynting!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.rebind_weight!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.record_digest), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.reset_work!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.runtime), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.spatial_local!), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.split_power), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_call), typeof(SolpropJulia.state_power), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), Module, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), NamedTuple{(:zs, :counts, :history_z, :history_predicted, :history_row, :ledger, :rows, :orders, :reason, :cost, :floor_proposal, :stage, :category, :message, :alarm, :alarm_z, :first_alarm, :split_powers, :split_steps), Tuple{Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Float64, Int64, Int64, String, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlany_getattr), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlmodule_seval), Module, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.JlWrap.pyjlmodule_seval), Module, PythonCall.Py}) # recompile +precompile(Tuple{typeof(PythonCall.pyconvert_return), Bool}) +precompile(Tuple{typeof(PythonCall.pyis), PythonCall.Py, PythonCall.Py}) +precompile(Tuple{typeof(PythonCall.Utils.size_to_fstrides), Int64, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Utils.size_to_fstrides), Int64, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_size), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_size), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{2}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_size), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{3}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}, Type{Base.Complex{Float64}}, Tuple{Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}, Type{Bool}, Tuple{Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}, Type{Float64}, Tuple{Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{1}, Type{Int64}, Tuple{Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{2}, Type{Base.Complex{Float64}}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{2}, Type{Float64}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{2}, Type{UInt8}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{3}, Type{Base.Complex{Float64}}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(PythonCall.Wrap.pyarray_get_strides), PythonCall.Wrap.PyArraySource_ArrayStruct, Base.Val{3}, Type{Float64}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(REPLExt.__init__)}) # recompile +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{1}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{2}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{3}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{4}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{5}}) +precompile(Tuple{typeof(SolpropJulia.adams_trial_width!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Base.Val{6}}) +precompile(Tuple{typeof(SolpropJulia.adams_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.approach), SolpropJulia.Policy, Float64, NamedTuple{(:dz, :target, :landed, :at), Tuple{Float64, Int64, Bool, Float64}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_edge!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Nothing, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Nothing}) +precompile(Tuple{typeof(SolpropJulia.bind_monitor!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 2, false, true, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_spatial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}, Nothing, Int64}) +precompile(Tuple{typeof(SolpropJulia.bind_spatial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}, Nothing, Int64}) +precompile(Tuple{typeof(SolpropJulia.bind_spatial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, Int64}) +precompile(Tuple{typeof(SolpropJulia.bind_spatial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}, PythonCall.PyArray{Float64, 2, true, false, Float64}, Int64}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_constants!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Vararg{Float64, 4}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_constants!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Vararg{Float64, 4}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_table!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, String, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_table!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, String, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_table!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, String, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.bind_stage_table!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, String, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.clenshaw_points!), PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, false, true, Float64}, Float64, Float64, PythonCall.PyArray{Float64, 3, false, false, Float64}, PythonCall.PyArray{Float64, 2, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.colsum!), SolpropJulia.var"#edge_energy##0#edge_energy##1"{Float64, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Array{Float64, 1}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.colsum!), SolpropJulia.var"#edge_energy##2#edge_energy##3"{Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Array{Float64, 1}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.commit!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.compile!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, false, true, Float64}, PythonCall.PyArray{Float64, 3, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, false, true, Float64}, PythonCall.PyArray{Float64, 3, true, false, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_march!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, Int64, Bool, Bool, Bool, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 3, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_stages_at!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, PythonCall.PyArray{Float64, 1, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.configure_stages_at!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, PythonCall.PyArray{Float64, 1, true, true, Float64}}) +precompile(Tuple{typeof(SolpropJulia.copy_between!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}}) +precompile(Tuple{typeof(SolpropJulia.copy_between!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.copy_state!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.create_free), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}}) +precompile(Tuple{typeof(SolpropJulia.create_modal), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}}) +precompile(Tuple{typeof(SolpropJulia.create), PythonCall.PyDict{Any, Any}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.device_name), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.dzeros), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Type, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(SolpropJulia.dzeros), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Type, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(SolpropJulia.each_column!), SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.each_column!), SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#poynting!##0#poynting!##1"{Base.Complex{Float64}, Float64, Float64, Int64, Bool, Array{Float64, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#poynting!##2#poynting!##3"{Float64, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#poynting!##4#poynting!##5"{Float64, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.each!), SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.factor), SolpropJulia.Policy, Float64, Int64, Float64}) +precompile(Tuple{typeof(SolpropJulia.fir_interior!), Array{Float64, 2}, Array{Float64, 2}, Int64, Int64, Int64, NTuple{5, Float64}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_candidate), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.host_state), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.landing), SolpropJulia.Policy, Float64, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.load!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_accept!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Bool, 1, true, true, Bool}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_run!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Int64, 1, true, true, Int64}, PythonCall.PyArray{Float64, 1, true, true, Float64}, PythonCall.PyArray{Int64, 1, true, true, Int64}}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_start!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{Nothing}, Float64}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.march_trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{Nothing}, Float64, Float64, NamedTuple{(:nodes, :rows, :held, :order, :orders), Tuple{Array{Float64, 1}, Array{Int64, 1}, Int64, Int64, Array{Int64, 1}}}}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.material_stage!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Int64}) +precompile(Tuple{typeof(SolpropJulia.monitor_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Int64, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.monitor_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Int64, Int64, Int64}) +precompile(Tuple{typeof(SolpropJulia.node_spectra!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.node_spectra!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.node_spectra!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.node_spectra!), Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:closure, :S, :electric, :magnetic, :weighted, :signal, :other, :inverse, :fluence, :magnitudes, :peaks), Tuple{Array{Base.Complex{Float64}, 2}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}, SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.occupancy), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.path_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Function, Array{Base.Complex{Float64}, 2}, Int64}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Function, Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, Function, Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Function, Array{Base.Complex{Float64}, 2}, Int64, Vararg{Int64}}) +precompile(Tuple{typeof(SolpropJulia.plan), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, Function, Array{Float64, 2}, Int64}) +precompile(Tuple{typeof(SolpropJulia.plasma_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}, Vararg{Int64, 4}}) +precompile(Tuple{typeof(SolpropJulia.plasma_workspace), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:has, :int, :real, :flag, :string, :array, :value), Tuple{SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##1#HostInput##2"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##3#HostInput##4"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##5#HostInput##6"{PythonCall.PyDict{Any, Any}, SolpropJulia.var"#has#HostInput##0"{PythonCall.PyDict{Any, Any}}}, SolpropJulia.var"#HostInput##7#HostInput##8"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##9#HostInput##10"{PythonCall.PyDict{Any, Any}}, SolpropJulia.var"#HostInput##11#HostInput##12"{PythonCall.PyDict{Any, Any}}}}, Vararg{Int64, 4}}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.poynting!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool}) +precompile(Tuple{typeof(SolpropJulia.proposal), SolpropJulia.Policy, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.py_min), Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.quiet_capped), SolpropJulia.Policy, Float64, Bool}) +precompile(Tuple{typeof(SolpropJulia.reached), Float64, Float64, Int64}) +precompile(Tuple{typeof(SolpropJulia.record_digest), String}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.reset!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.rk4!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{NamedTuple{(:edges, :c), Tuple{Array{Float64, 1}, Array{Float64, 3}}}}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.run_march), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, SolpropJulia.MarchConfig{Nothing}, Array{Float64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Bool, 1}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Int64, 1}}) +precompile(Tuple{typeof(SolpropJulia.spatial_local!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.spatial_local!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.spatial_local!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.spatial_local!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64, Float64}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.split_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.stage_values), NamedTuple{(:edges, :lower, :upper, :c), Tuple{Array{Float64, 1}, Float64, Float64, Array{Float64, 3}}}, Array{Float64, 1}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.state_power), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.stencil), SolpropJulia.Policy, Float64, Float64, Array{Float64, 1}, Array{Int64, 1}, Int64, Bool}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.trial!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}, Float64}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Base.Complex{Float64}, 1}}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Base.Complex{Float64}, 2}}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Bool, 1}}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Float64, 1}}) +precompile(Tuple{typeof(SolpropJulia.upload), NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool}}, Array{Float64, 2}}) +precompile(Tuple{typeof(SolpropJulia.vexp), Float64}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}) +precompile(Tuple{typeof(SolpropJulia.warm!), SolpropJulia.Engine{NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}}}) +precompile(Tuple{typeof(StaticArrayInterface._accum_dims), Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}}) +precompile(Tuple{typeof(StaticArrayInterface._accum_dims), Tuple{Int64, Int64}, Tuple{Int64, Int64}}) +precompile(Tuple{typeof(StaticArrayInterface._find_first_true), Tuple{Bool, Bool}}) +precompile(Tuple{typeof(StaticArrayInterface._find_first_true), Tuple{Bool, Bool, Bool}}) +precompile(Tuple{typeof(StaticArrayInterface.known_offsets), Type{StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}, Int64}) +precompile(Tuple{typeof(StaticArrayInterface.known_offsets), Type{StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}, Int64}) +precompile(Tuple{typeof(StaticArrayInterface.known_offsets), Type{StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}, Int64}) +precompile(Tuple{typeof(StaticArrayInterface.rank_to_sortperm), Tuple{Static.StaticInt{1}, Static.StaticInt{2}}}) +precompile(Tuple{typeof(StaticArrayInterface.rank_to_sortperm), Tuple{Static.StaticInt{1}, Static.StaticInt{2}, Static.StaticInt{3}}}) +precompile(Tuple{typeof(StaticArrayInterface.static_length), Base.OneTo{Int64}}) +precompile(Tuple{typeof(Static.eachop), typeof(Static._get_known), Tuple{Static.StaticInt{1}}, Type}) +precompile(Tuple{typeof(Static.known), Type{var"#s22"} where var"#s22"<:Tuple}) +precompile(Tuple{typeof(Static._return_int), Int64}) +precompile(Tuple{typeof(Static.static), Bool}) +precompile(Tuple{typeof(Static.static), Int64}) +precompile(Tuple{Type{Pair{Any, Tuple{Bool, Bool}}}, Any, Any}) # recompile +precompile(Tuple{Type{Pair{Int64, Int64}}, Any, Any}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##0#adams_trial_width!##1"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{1, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{2, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{3, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{4, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{5, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Array{Float64, 2}, Bool, Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#adams_trial_width!##2#adams_trial_width!##3"{6, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Float64, Nothing, Bool, Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##2#rk4!##3"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##4#rk4!##5"{Float64, Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#rk4!##6#rk4!##7"{Float64, Float64, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Float64, Int64, typeof(Base.:(+)), SolpropJulia.var"#weighted_norm##0#weighted_norm##1"{Array{Base.Complex{Float64}, 2}, Float64, Float64, Float64, Array{Bool, 1}, Array{Float64, 1}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##4#adams_trial_width!##5"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{1, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{2, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{3, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{4, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{5, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#adams_trial_width!##6#adams_trial_width!##7"{6, Float64, Tuple{Float64, Float64, Float64}, Array{Float64, 1}, Float64, Float64, Base.Complex{Float64}, Float64, Array{Bool, 1}, Array{Bool, 1}, Bool, Array{Int64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Int64, Int64}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#combine!##4#combine!##5"{Int64, Tuple{Float64, Float64, Float64}, NTuple{7, Float64}, NTuple{7, Float64}, Array{Bool, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#band_alarm##0#band_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#20#21", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Tuple{Float64, Float64}, Int64, Base.Broadcast.BroadcastFunction{typeof(Base.:(+))}, SolpropJulia.var"#quadrature_alarm##0#quadrature_alarm##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}, StrideArraysCore.AbstractPtrArray{Tuple{Float64, Float64}, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Tuple{Float64, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#32#33", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 3, (1, 2, 3), Tuple{Int64, Int64, Int64}, Tuple{Nothing, Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#37#38", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 3, (1, 2, 3), Tuple{Int64, Int64, Int64}, Tuple{Nothing, Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#column_energy##0#column_energy##1"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##0#edge_energy##1"{Float64, Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#colsum!##0#colsum!##1"{SolpropJulia.var"#edge_energy##2#edge_energy##3"{Array{Base.Complex{Float64}, 2}}, Array{Float64, 1}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#plasma_columns!##0#plasma_columns!##1"{Array{Float64, 2}, Int64, Float64, Float64, Float64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#population_columns!##0#population_columns!##1"{Array{Float64, 2}, Int64, Float64, Int64, Int64, Float64, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Bool, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Float64, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_column!##0#each_column!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, SolpropJulia.var"#spatial_local!##4#spatial_local!##5"{Float64, Float64, Float64, Float64, Float64, Int64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#absorber!##0#absorber!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#adams_start!##0#adams_start!##1"{Array{Float64, 1}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#add_plasma_spectra!##0#add_plasma_spectra!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##0#analytic_signal!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#analytic_signal!##2#analytic_signal!##3"{Array{Base.Complex{Float64}, 2}, Float64, Int64, Float64, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#bind_monitor!##0#bind_monitor!##1"{Array{Int32, 2}, Array{UInt8, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#collar_factor##0#collar_factor##1"{Array{Float64, 1}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#columns_into!##0#columns_into!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#convolve!##0#convolve!##1"{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#finish_band!##0#finish_band!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#finish_source!##0#finish_source!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Int64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_absorber!##0#free_absorber!##1"{Int64, Int64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#free_propagators!##0#free_propagators!##1"{Float64, Bool, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#gather_columns!##0#gather_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Int64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#integrate_samples!##0#integrate_samples!##1"{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Float64, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#mask!##0#mask!##1"{Array{Base.Complex{Float64}, 2}, Array{Bool, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#material_stage!##0#material_stage!##1"{Int64, Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_envelope!##0#nonlinear_envelope!##1"{Array{Float64, 2}, Bool, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##0#nonlinear_nodes!##1"{Array{Float64, 2}, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#nonlinear_nodes!##2#nonlinear_nodes!##3"{Array{Float64, 2}, Array{Float64, 2}, Float64, Array{Float64, 2}, Float64, Float64, Array{Float64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#path_propagators!##0#path_propagators!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##0#plasma_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##2#plasma_samples!##3"{Array{Float64, 2}, Float64, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#plasma_samples!##4#plasma_samples!##5"{Array{Float64, 2}, Float64, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#pool_copy!##0#pool_copy!##1"{Base.SubArray{Base.Complex{Float64}, 2, Array{Base.Complex{Float64}, 3}, Tuple{Base.Slice{Base.OneTo{Int64}}, Base.Slice{Base.OneTo{Int64}}, Int64}, true}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##0#population_samples!##1"{Array{Float64, 2}, Tuple{Float64, Array{Float64, 2}, Vararg{Float64, 5}}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##2#population_samples!##3"{Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##4#population_samples!##5"{Array{Float64, 2}, Float64, Float64, Bool, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#population_samples!##6#population_samples!##7"{Float64, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##0#poynting!##1"{Base.Complex{Float64}, Float64, Float64, Int64, Bool, Array{Float64, 2}, Int64, Array{Base.Complex{Float64}, 2}, Bool, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##2#poynting!##3"{Float64, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#poynting!##4#poynting!##5"{Float64, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#propagators!##2#propagators!##3"{NTuple{7, Float64}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Int64, Bool, Array{Float64, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_drive!##0#raman_drive!##1"{Array{Float64, 2}, Array{Float64, 2}, Int64, Bool, Array{Float64, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#raman_products!##0#raman_products!##1"{Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Float64, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#rk4!##0#rk4!##1"{Float64, Float64, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#scatter!##0#scatter!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#scatter_columns!##0#scatter_columns!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, Int64, Array{Int64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##2#source_free!##3"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##4#source_free!##5"{Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##6#source_free!##7"{Float64, Float64, Array{Float64, 1}, Float64, Array{Float64, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_free!##8#source_free!##9"{Array{Base.Complex{Float64}, 2}, Bool, Array{Bool, 1}, Array{Float64, 1}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##0#source_spectral!##1"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##10#source_spectral!##11"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##2#source_spectral!##3"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##4#source_spectral!##5"{Int64, Float64, Float64, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##6#source_spectral!##7"{Array{Base.Complex{Float64}, 2}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#source_spectral!##8#source_spectral!##9"{Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spatial_local!##0#spatial_local!##1"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spatial_local!##2#spatial_local!##3"{Base.Complex{Float64}, Float64, Int64, Bool, Int64, Int64, Int64, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#spectral_plasma!##2#spectral_plasma!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Bool, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Int64, 1}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##0#split_free!##1"{Array{Float64, 1}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_free!##2#split_free!##3"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Base.Complex{Float64}, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#split_modal!##0#split_modal!##1"{Array{Float64, 1}, Array{Float64, 2}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#trial!##2#trial!##3"{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Int64, NTuple{6, Float64}, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#each_on!##0#each_on!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, SolpropJulia.var"#trial!##4#trial!##5"{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Int64, Int64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#gemm!##0#gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Bool, Bool}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#occupancy##0#occupancy##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Int32, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Int32}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#rowsum!##0#rowsum!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}, SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Int64, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#rowsum!##0#rowsum!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, StrideArraysCore.AbstractPtrArray{Float64, 1, (1,), Tuple{Int64}, Tuple{Nothing}, Tuple{Static.StaticInt{1}}, Float64}, SolpropJulia.var"#add_power!##0#add_power!##1"{Array{Float64, 2}, Array{Float64, 1}, Int64, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#thin_gemm!##0#thin_gemm!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, Int64, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, Int64, Float64, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, StrideArraysCore.StrideReset{Int64}}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{Polyester.BatchClosure{SolpropJulia.var"#transform_all!##0#transform_all!##1", ManualMemory.Reference{Tuple{Static.StaticInt{1}, Static.StaticInt{1}, Polyester.NoLoop, Polyester.CombineIndices, Int64, typeof(SolpropJulia.transform_block!), SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Tuple{StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}, StrideArraysCore.AbstractPtrArray{Base.Complex{Float64}, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Base.Complex{Float64}}}, Tuple{StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}, StrideArraysCore.AbstractPtrArray{Float64, 2, (1, 2), Tuple{Int64, Int64}, Tuple{Nothing, Nothing}, Tuple{Static.StaticInt{1}, Static.StaticInt{1}}, Float64}}}}, false, Tuple{}}}, Function}) +precompile(Tuple{Type{PolyesterWeave.UnsignedIteratorEarlyStop{U} where U}, UInt64, UInt32}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 1, true, true, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 2, true, false, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, 3, true, false, Base.Complex{Float64}}}, Base.Val{:new}, Ptr{Base.Complex{Float64}}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, N, M, L, R} where R where L where M where N}, PythonCall.PyArray{Base.Complex{Float64}, 2, false, true, Base.Complex{Float64}}}) +precompile(Tuple{Type{PythonCall.PyArray{Base.Complex{Float64}, N, M, L, R} where R where L where M where N}, PythonCall.PyArray{Base.Complex{Float64}, 2, true, true, Base.Complex{Float64}}}) +precompile(Tuple{Type{PythonCall.PyArray{Bool, 1, true, true, Bool}}, Base.Val{:new}, Ptr{Bool}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.Py}, Array{Float64, 1}}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 1, false, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 1, true, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 2, false, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 2, true, false, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 2, true, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 3, false, false, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 3, false, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 3, true, false, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Float64, 3, true, true, Float64}}, Base.Val{:new}, Ptr{Float64}, Tuple{Int64, Int64, Int64}, Tuple{Int64, Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{Int64, 1, true, true, Int64}}, Base.Val{:new}, Ptr{Int64}, Tuple{Int64}, Tuple{Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{UInt8, 2, true, true, UInt8}}, Base.Val{:new}, Ptr{UInt8}, Tuple{Int64, Int64}, Tuple{Int64, Int64}, PythonCall.Py, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.PyArray{UInt8, N, M, L, R} where R where L where M where N}, PythonCall.PyArray{UInt8, 2, true, true, UInt8}}) +precompile(Tuple{Type{PythonCall.Py}, Float64}) +precompile(Tuple{Type{PythonCall.Py}, Function}) +precompile(Tuple{Type{PythonCall.Py}, Int64}) +precompile(Tuple{Type{PythonCall.Py}, Module}) +precompile(Tuple{Type{PythonCall.Py}, Nothing}) +precompile(Tuple{Type{PythonCall.Py}, PythonCall.Py}) +precompile(Tuple{Type{PythonCall.Py}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}}}) +precompile(Tuple{Type{PythonCall.Py}, Tuple{Array{Float64, 2}, Array{Float64, 1}}}) +precompile(Tuple{Type{PythonCall.Py}, Tuple{Float64, Float64}}) +precompile(Tuple{Type{PythonCall.Py}, Tuple{UInt64, UInt64}}) +precompile(Tuple{Type{SolpropJulia.Blocked{P} where P}, Array{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, 1}, Array{Base.UnitRange{Int64}, 1}, Int64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, false, 2, Int64}}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spatial_shape, :op, :field_scale, :absorber_scale, :spatial_rate, :temporal_rate, :in_stage, :nc, :embedded), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Tuple{Int64, Int64}, NamedTuple{(:k_squared, :k_squared_low, :kperp_sq, :kperp_sq_low, :frame, :spectral_rate, :prefactor_numerator, :prefactor_clamped, :active, :kperp_rate, :evanescent_rate), Tuple{Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Base.Complex{Float64}, 1}, Array{Base.Complex{Float64}, 1}, Array{Bool, 1}, Array{Float64, 1}, Float64}}, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Bool, Int64, Bool}}, NamedTuple{(:adams, :path, :raman, :monitor, :edge, :march, :spatial, :plasma, :y, :candidate, :lab, :source, :error, :stages, :forward, :inverse, :physical, :loss, :fine, :modal, :projected, :analytic, :absorber, :absorber_spec, :coarse, :coarse_spec, :spatial_inverse, :spatial_forward, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Nothing, Nothing, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 3, Tuple{Int64, Int64}}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, NamedTuple{(:phi, :prefactor, :delta, :weights, :delta_device, :weights_device, :material, :tables, :constants), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Base.Dict{String, Any}, Array{Float64, 1}}}, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, NamedTuple{(:kernel, :factor, :thg, :products, :drive, :frequency, :weights, :nodal, :first, :second, :signal, :signal_forward, :signal_inverse, :forward, :inverse), Tuple{Array{Base.Complex{Float64}, 1}, Float64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Int64, 1}, Array{Int64, 1}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}}, Nothing, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}, FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Nothing, Nothing, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}, FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{SolpropJulia.Engine{C, W} where W where C}, NamedTuple{(:backend, :T, :tasks, :scratch, :fft_threads, :raman_fft_threads, :transverse_fft_threads, :envelope, :low_storage, :free, :split, :analytic, :analytic_factor, :factor, :rtol, :atol, :cache_propagators, :scale, :crop, :uncrop, :mask, :norm_mask, :weights, :uniform, :window, :omega_window, :rate, :coarse_rate, :a, :b, :e, :nodes_c, :nt, :nf, :split_active, :spectral, :spectral_absorber, :linear, :prefactor, :synthesis, :projection, :projection_coarse, :embedded, :spatial_absorber, :in_stage, :absorber_rate, :nc), Tuple{KernelAbstractions.POCL.POCLKernels.POCLBackend, typeof(DataType), Int64, Base.Dict{Any, Any}, Int64, Int64, Int64, Bool, Bool, Bool, Bool, Bool, Float64, Float64, Float64, Float64, Bool, Float64, Array{Int64, 1}, Array{Int64, 1}, Array{Bool, 1}, Array{Bool, 1}, Array{Float64, 1}, Bool, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64, Int64, Bool, Bool, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Bool, Array{Float64, 2}, Bool, Array{Float64, 1}, Int64}}, NamedTuple{(:node_band, :node_fine, :band_source, :band_coarse, :node_inverse, :node_forward, :absorber_spec_band, :adams, :path, :monitor, :edge, :march, :spatial, :forward_stage, :statistics, :raman, :plasma, :y, :candidate, :lab, :source, :fsal, :error, :stages, :forward, :inverse, :fine, :modal, :nodes, :analytic, :projected, :projected_coarse, :coarse_spec, :absorber, :absorber_spec, :coarse, :inverse_plan, :forward_plan, :analytic_forward, :analytic_inverse, :coarse_inverse, :coarse_forward), Tuple{Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:store, :states, :rates, :moments, :carried, :endpoint, :host, :device, :sizes, :compensated), Tuple{Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, NamedTuple{(:predictor, :corrector, :defects, :spans, :cpredictor, :ccorrector, :cdefects, :rate, :slots), Tuple{Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 1}, Array{Int64, 1}}}, Array{Int64, 1}, Bool}}, Nothing, NamedTuple{(:columns, :buckets, :power, :split, :histogram), Tuple{Array{Float64, 1}, Array{Int32, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Base.RefValue{Any}, Nothing, NamedTuple{(:coefficients, :parameters, :taps, :floor, :dt, :field_scale, :inverse_omega, :derivative, :rate, :fraction, :live, :scratch, :knots, :integrand, :current, :gated, :edge, :projected, :edge_projected, :coarse, :coarse_edge, :spectrum, :edge_spectrum, :fractions, :peaks, :parts), Tuple{Array{Float64, 2}, Array{Float64, 1}, Array{Float64, 1}, Bool, Float64, Float64, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Int32, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 2}}}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 2}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 3}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, Array{Base.Complex{Float64}, 2}, Array{Float64, 2}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, -1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.cFFTWPlan{Base.Complex{Float64}, 1, true, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Base.Complex{Float64}, 1, false, 2, Int64}}, SolpropJulia.Blocked{FFTW.rFFTWPlan{Float64, -1, false, 2, Int64}}}}, Bool, Int64, Float64, Float64}) +precompile(Tuple{Type{Static.StaticInt{N} where N}, Int64}) +precompile(Tuple{Type{Tuple}, Tuple{Int64, Int64}}) +precompile(Tuple{Type{UInt128}, UInt64}) +precompile(Tuple{UnsafePointers.var"##19#20", Vararg{Any, 5}}) +precompile(Tuple{UnsafePointers.var"##21#22", Vararg{Any, 5}}) +precompile(Tuple{UnsafePointers.var"##23#24", Vararg{Any, 5}}) From 3933d4f337a04350e4380316c24ebb003c9fcb9d Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 09:31:26 +0000 Subject: [PATCH 059/107] Julia: a handoff note for the Mac (a CPU comparison, then a Metal extension) [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XGENPuYVwK6ASX5LHmbgEY --- julia/METAL_HANDOFF.md | 158 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 158 insertions(+) create mode 100644 julia/METAL_HANDOFF.md diff --git a/julia/METAL_HANDOFF.md b/julia/METAL_HANDOFF.md new file mode 100644 index 000000000..a696837f9 --- /dev/null +++ b/julia/METAL_HANDOFF.md @@ -0,0 +1,158 @@ +# Handoff: the Julia backend on a Mac (CPU comparison, then Metal) + +For the agent picking this up on the maintainer's Mac (Apple M5 Max). The work is draft +PR #559, branch `feature/julia-backend-experiment` (do not merge; heads `[skip ci]`). +Read `AGENTS.md`, then [README.md](README.md) (setup, variables, files) and +[STATUS.md](STATUS.md) (what the engine is, what made it fast, the measurements, what is +left). The ledger rows are in `docs/dev/benchmarks.md`, "Julia backend experiment". +Native ideas found on the way are #560. + +## Where it stands + +`backend="julia"` steps solprop's translated problem behind the same `StepDriver` seam +as native. The engine is one Julia source (`julia/src`), run three ways: +- on a CPU, by Polyester tasks; +- on NVIDIA GPUs, through CUDA.jl (`ext/SolpropJuliaCUDAExt.jl`, environment `julia/cuda`); +- on AMD GPUs, through AMDGPU.jl (`ext/SolpropJuliaAMDGPUExt.jl`, environment `julia/rocm`). + +It runs in binary64 or binary32 (SEP 33). The exponential Adams march itself runs in the +engine (`src/march.jl`). Its windows match native's steps, and match its fields to +rounding. + +Julia's window time over native's, at commit `a6722029` (below 1, Julia is faster): + +| Machine | Geometric mean | Range | Notes | +|---|---:|---|---| +| Intel Xeon Gold 6240, 16 threads | 1.13 | 0.78 to 1.26 | faster on `line`, `ctc_reduced`, `h2_raman_6ps` | +| Same, one thread | | 0.97 to 1.56 | | +| NVIDIA A40, binary64 | 1.97 | | | + +The NVIDIA H200 (2.39) and the AMD Instinct MI325X (2.48) were measured before the fix +for compilation inside the first window, so their radial and free-space rows overstate +the gap. + +## Step 1: a light CPU comparison with native on the M5 Max + +PR #10's prototype was last measured on this Mac. The engine has since been rewritten, +so this is the first measurement of the current one there. + +1. Set up, from a checkout of the branch: + + ```sh + uv sync --extra julia # native builds as AGENTS.md says + juliaup add 1.13 # or let the bootstrap download the release + export SOLPROP_JULIA_EXE=$(julia +1.13 -e 'print(joinpath(Sys.BINDIR, "julia"))') + uv run --no-sync python julia/bootstrap.py + ``` + + The first package build replays `src/precompile_trace.jl` (about a minute; see + "Start latency" below). +2. Run the tests: `uv run --no-sync pytest tests/backends/test_julia.py -n 4`. They + should all pass, CPU only; the GPU-marked ones are deselected. +3. Run the comparison. Use the performance cores only; macOS cannot pin threads, so + find their count with `sysctl hw.perflevel0.physicalcpu`: + + ```sh + P=$(sysctl -n hw.perflevel0.physicalcpu) + uv run --no-sync python -m benchmarks ab --baseline-backend native --candidate-backend julia \ + --baseline-python .venv/bin/python --case rdw --case argon_blueshift --case h2_raman_6ps \ + --case ctc_reduced --case radial_filament_256 --case line --case kerr_beam_192 \ + --stepper default --noise none --threads 1,$P --length 0.02 --rounds 3 --repeats 1 \ + --out + ``` + + Record the commit, the machine and the rows in the ledger's Julia section. +4. Things to watch on Apple silicon: + - **Efficiency cores.** Polyester's tasks are static: a task on an efficiency core + holds back every pass, so more threads than performance cores may be slower. + - **BLAS.** Julia uses OpenBLAS through libblastrampoline. Accelerate (AppleAccelerate.jl) + may be faster for the GEMMs; the prototype had an Accelerate option. + - **SIMD.** FFTW and `src/vmath.jl` (branch-free `exp`/`log`, plain Julia) vectorise + with NEON's two binary64 lanes, not AVX-512's eight; the plasma's gains may be smaller. + - **Compilation in the window.** `test_julia_first_window_compiles_nothing` holds the + first timed window to under 50 ms of compilation; check it passes here. + +## Step 2: a Metal extension + +Metal.jl 1.10 has AbstractFFTs plans (on MPSGraph), `mul!` through MPS, and a +KernelAbstractions backend; AcceleratedKernels supports it. So the device layer, kernels, +reductions and scans should carry over, as they did for AMD tonight. That took about an +hour from writing the extension to all tests passing; see commit "an AMDGPU extension +and its environment" for the pattern: +- the extension file; +- the environment `julia//Project.toml`, resolved into its own `Manifest.toml`; +- the `[weakdeps]` and `[extensions]` entries in `julia/Project.toml`; +- `_GPU_PACKAGES` and the device check in `src/solprop/backends/julia/_runtime.py`; +- the source digest's file list in the same module; +- `bootstrap.py --`; +- the benchmark worker keeping the named device under `--device`. + +The one real problem is binary64. **Apple GPUs have none**, and the engine deliberately +keeps these in binary64 on the device, even in binary32 runs (SEP 33, 4.1 item 3): + +| Where | What | +|---|---| +| `src/modal.jl` (`linear=upload(..., ComplexF64)`) | the linear operator | +| `src/dopri.jl` (`propagators!`) | the propagators' exponents, `exp(h L)` | +| `src/adams.jl` (`adams_trial_width!`: `x = ComplexF64(step * linear[f, m])`, `phi_values`) | the Adams phi functions | +| `src/stages.jl` (`delta_device`, `path.phi`) | a varying operator's stage increments | +| `src/free.jl` (the `op` tables, `free_element`, `free_propagators!`) | the free-space operator and its longitudinal root | + +Two ways round it: + +1. **Form those on the CPU in binary64 and hand the device binary32 results.** + - Unified memory makes the handoff cheap, and Polyester threads on the host can form + them. + - The phi functions depend on `h L` per element and are formed every trial: about + 100 ns an element, so rdw's 10 k elements cost about 1 ms on one core. + - DOPRI's propagators change only with `dz`. + - It suits the capillary routes (rdw, argon, ctc, h2). Cartesian recomputes its root + per element and stage, which is the costly case. +2. **Double-float arithmetic** (a binary64 value as a pair of binary32s) in those + kernels, as the mlx backend's Adams flow does (#543). It is general but more work. + +Suggested order: +1. Admit `precision="single"` only on Metal; refuse binary64 by name. +2. Get rdw (modal, Adams) running with option 1, then argon, then radial. +3. Hold off on free space. +4. Use `--fft-size pow2`: MLX's GPU FFTs fell back to Bluestein above 4096 points for + other sizes (#543). Whether MPSGraph does the same is unchecked. + +Then compare against the mlx backend on the same windows: Julia's single source against +hand-written MLX. + +Things to check early on Metal: +- **In-place and batched plans.** Whether Metal.jl's FFT plans support in-place + `plan_bfft!`/`plan_fft!` and transforms along dimension 1 of a matrix. The engine uses + both; `src/observe.jl` and `src/responses.jl` have the in-place ones. +- **Real views.** `reinterpret` of an `MtlArray` (`real_rows` in `src/launch.jl`, for + complex-by-real products). +- **Atomics.** Binary32 atomics in local memory (`bucket_kernel!` in `src/observe.jl`). +- **Scalar indexing.** `Metal.allowscalar(false)`, as the other extensions set. + +## What this branch learned (applies on any device) + +- **Kernel bodies capture values, not types.** A closure that captures `Type{T}` or a + `Core.Box` is refused on a GPU. `SOLPROP_JULIA_CHECK=1`, which the tests set, refuses + it on a CPU too. Capture `zero(T)` and similar as values. +- **Nothing may compile inside a timed window.** The benchmark worker's warm-up runs + without a boundary monitor, so construction must warm every bridge entry with the + argument types a run passes. A read-only NumPy array is a different bridge type from a + writable one. Check with juliacall's `PYTHON_JULIACALL_TRACE_COMPILE=` (with + `PYTHON_JULIACALL_TRACE_COMPILE_TIMING=yes`) around a timed run. +- **Start latency.** + - The first engine in a process compiles its configuration's specialisations: 34 to + 64 s, cut to 11 to 14 s by replaying `src/precompile_trace.jl` when the package + builds. + - Regenerate the trace after large changes: run each case with the trace variable set, + collect the `precompile(` lines, `sort -u`. + - On a new device, add its specialisations the same way. + - A PackageCompiler system image would remove the rest; it has not been tried. +- **GPU windows are host-bound** on GPUs with full-rate arithmetic. Count launches and + allocations per trial before tuning kernels; the scratch cache in `c.scratch` + (`scratch` in `src/launch.jl`) exists for this. +- **Benchmark hygiene.** + - Nothing else on the machine while an A/B runs: tonight's own test runs contaminated + one. + - Measured FFT plans differ between processes; for bit-for-bit comparisons set + `SOLPROP_FFTW_PLAN=estimate`. From 52b9a4560d2e88eeef28bfa15264bf462204a5cb Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 10:35:25 +0000 Subject: [PATCH 060/107] Julia: a Metal extension, with double-float for the operator's exponents and the Adams flow [skip ci] Apple GPUs have no binary64. A binary32 run now forms the operator's exponents, the propagators and the Adams phi functions in a wide type: binary64 as before, or a double-float (two binary32s, about 48 bits; julia/src/dfloat.jl, the mlx backend's primitives), rounded once to binary32 either way. SOLPROP_JULIA_WIDE chooses it on any device (binary64 by default); Metal always takes df32 and refuses binary64 by name. Binary64 runs keep their arithmetic exactly (every bit-for-bit test passes). - SolpropJuliaMetalExt and the julia/metal environment (Metal.jl 1.12, private storage so that a host scalar access is an error); bootstrap --metal. - Free space in df32: each element's rate and prefactor formed once on the host in binary64, the rate held as a double-float table. - benchmarks ab --device-arm: one arm on its device, the other on the host. - Tests: the binary32 windows in both wide types; the double-float phi functions and propagator pair against binary64; binary64-only tests skipped on Metal. On the M5 Max's GPU every binary32 window passes (rdw RK and Adams, argon, h2 Raman, radial, line). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- .gitignore | 1 + benchmarks/ab.py | 22 +- benchmarks/worker.py | 2 +- julia/Manifest.toml | 6 +- julia/Project.toml | 2 + julia/README.md | 7 +- julia/bootstrap.py | 6 +- julia/ext/SolpropJuliaMetalExt.jl | 15 + julia/metal/LocalPreferences.toml | 3 + julia/metal/Manifest.toml | 1074 ++++++++++++++++++++++++ julia/metal/Project.toml | 7 + julia/src/SolpropJulia.jl | 11 +- julia/src/adams.jl | 88 +- julia/src/dfloat.jl | 205 +++++ julia/src/dopri.jl | 7 +- julia/src/free.jl | 48 +- julia/src/modal.jl | 7 +- julia/src/stages.jl | 11 +- src/solprop/backends/julia/_backend.py | 46 + src/solprop/backends/julia/_runtime.py | 12 +- tests/backends/test_julia.py | 55 +- 21 files changed, 1571 insertions(+), 64 deletions(-) create mode 100644 julia/ext/SolpropJuliaMetalExt.jl create mode 100644 julia/metal/LocalPreferences.toml create mode 100644 julia/metal/Manifest.toml create mode 100644 julia/metal/Project.toml create mode 100644 julia/src/dfloat.jl diff --git a/.gitignore b/.gitignore index 73b3fcf5c..84a43ed7c 100644 --- a/.gitignore +++ b/.gitignore @@ -54,3 +54,4 @@ docs/introduction/lessons/searchindex .julia-depot/ julia/LocalPreferences.toml julia/cuda/LocalPreferences.toml +!julia/metal/LocalPreferences.toml diff --git a/benchmarks/ab.py b/benchmarks/ab.py index 906e3dff9..4dab9c73b 100644 --- a/benchmarks/ab.py +++ b/benchmarks/ab.py @@ -77,15 +77,27 @@ def ab_options(parser: argparse.ArgumentParser) -> None: choices=BACKENDS, help="the candidate arm's backend; default: --backend", ) + parser.add_argument( + "--device-arm", + choices=("baseline", "candidate"), + help="run only this arm on its device (a GPU against a CPU build); the other " + "runs on the host at the row's width", + ) -def arm_configuration(configuration: Record, backend: str) -> Record: - """Return one arm's configuration: its backend and that backend's precision.""" +def arm_configuration( + configuration: Record, backend: str, device: bool | None = None +) -> Record: + """Return one arm's configuration: its backend and that backend's precision. + + `device`, when given, overrides the row's device flag for this arm alone. + """ return { **configuration, # "julia32" is the julia backend in single precision (the Julia experiment). "backend": "julia" if backend == "julia32" else backend, "precision": "single" if backend in ("mlx", "julia32") else "double", + **({} if device is None else {"device": device}), } @@ -204,6 +216,8 @@ def ab(args: argparse.Namespace) -> int: """Collect and summarise a paired comparison of two prepared builds.""" if args.rounds < 1 or args.repeats < 1 or args.timeout <= 0: raise SuiteError("rounds, repeats and timeout must be positive") + if args.device_arm is not None and args.device: + raise SuiteError("--device runs both arms on a device; --device-arm one") started = time.perf_counter() backends = { "baseline": args.baseline_backend or args.backend, @@ -266,7 +280,9 @@ def ab(args: argparse.Namespace) -> int: pythons[arm], { "configuration": arm_configuration( - row["configuration"], backends[arm] + row["configuration"], + backends[arm], + None if args.device_arm is None else arm == args.device_arm, ), "repeats": args.repeats, "fields": str( diff --git a/benchmarks/worker.py b/benchmarks/worker.py index 7610ecacf..58c9c3fcc 100644 --- a/benchmarks/worker.py +++ b/benchmarks/worker.py @@ -101,7 +101,7 @@ def runtime(backend: str, device: bool = False) -> Record: # A GPU run takes the GPU the environment names (rocm on AMD), else CUDA. named = os.environ.get("SOLPROP_JULIA_DEVICE") os.environ["SOLPROP_JULIA_DEVICE"] = ( - (named if named in {"cuda", "rocm"} else "cuda") if device else "cpu" + (named if named in {"cuda", "rocm", "metal"} else "cuda") if device else "cpu" ) from solprop.backends.julia import source_digest # noqa: PLC0415 diff --git a/julia/Manifest.toml b/julia/Manifest.toml index a8c81332a..c8f6df2bd 100644 --- a/julia/Manifest.toml +++ b/julia/Manifest.toml @@ -2,7 +2,7 @@ julia_version = "1.13.3" manifest_format = "2.1" -project_hash = "0ebf08b9c460789dacbdc3ddc7c3310f1b94422b" +project_hash = "4fa6779d3f296b1c200044814053d5b7a829e045" [[deps.AbstractFFTs]] deps = ["LinearAlgebra"] @@ -709,10 +709,14 @@ uuid = "bc9db228-6fd1-46b1-b175-748485922872" version = "0.0.0" [deps.SolpropJulia.extensions] + SolpropJuliaAMDGPUExt = "AMDGPU" SolpropJuliaCUDAExt = "CUDA" + SolpropJuliaMetalExt = "Metal" [deps.SolpropJulia.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" [[deps.Static]] deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] diff --git a/julia/Project.toml b/julia/Project.toml index aba704e28..62185a601 100644 --- a/julia/Project.toml +++ b/julia/Project.toml @@ -13,10 +13,12 @@ PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" [weakdeps] AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +Metal = "dde4c033-4e86-420c-a63e-0dd931031962" [extensions] SolpropJuliaAMDGPUExt = "AMDGPU" SolpropJuliaCUDAExt = "CUDA" +SolpropJuliaMetalExt = "Metal" [compat] Atomix = "1.7.0" diff --git a/julia/README.md b/julia/README.md index 90ef51a88..8064f43d6 100644 --- a/julia/README.md +++ b/julia/README.md @@ -25,6 +25,8 @@ controller and the output are solprop's own. The engine is the Julia package in | `observe.jl` | what the driver reads between steps: the state, the boundary monitor's and the transverse edge's sums, the Poynting statistics' power | | `../ext/SolpropJuliaCUDAExt.jl` | CUDA: the engine's arrays become `CuArray`s | | `../ext/SolpropJuliaAMDGPUExt.jl` | AMD GPUs: the engine's arrays become `ROCArray`s | +| `../ext/SolpropJuliaMetalExt.jl` | Apple GPUs: the engine's arrays become `MtlArray`s; binary32 only | +| `dfloat.jl` | double-float (a value as two binary32s, about 48 bits): the operator's exponents, the propagators and the Adams flow where binary64 is absent or slow | ## Setting up @@ -34,7 +36,7 @@ checksummed release): ```sh uv sync --extra julia export SOLPROP_JULIA_EXE=$(julia +1.13 -e 'print(joinpath(Sys.BINDIR, "julia"))') -uv run --no-sync python julia/bootstrap.py # --cuda or --rocm for a GPU environment too +uv run --no-sync python julia/bootstrap.py # --cuda, --rocm or --metal for a GPU environment too # --cuda-local: CUDA.jl on the system toolkit, beside a native build linked to it ``` @@ -45,7 +47,8 @@ solprop is installed without `-e`. A run then takes `backend="julia"`: | Variable | Meaning | |---|---| | `SOLPROP_JULIA_THREADS` | the engine's threads (default 1); the benchmark harness sets it to the width | -| `SOLPROP_JULIA_DEVICE` | `cpu` (default), `cuda` or `rocm`, which load `julia/cuda` or `julia/rocm`: CUDA.jl or AMDGPU.jl resolved with the engine | +| `SOLPROP_JULIA_DEVICE` | `cpu` (default), `cuda`, `rocm` or `metal`, which load `julia/cuda`, `julia/rocm` or `julia/metal`: CUDA.jl, AMDGPU.jl or Metal.jl resolved with the engine. `metal` runs `precision="single"` only | +| `SOLPROP_JULIA_WIDE` | a binary32 run's wide type for the operator's exponents, the propagators and the Adams flow: `binary64` (default) or `df32` (double-float, `src/dfloat.jl`); `metal` always uses `df32`. Binary64 runs ignore it | | `SOLPROP_JULIA_MARCH` | `host`: the Python Adams march in place of the engine's (`src/march.jl`) | | `SOLPROP_FFTW_PLAN` | `estimate`, `measure` (default) or `patient` | | `SOLPROP_JULIA_TIMING` | `1`: the engine's section timers (`julia/profile.py` prints them) | diff --git a/julia/bootstrap.py b/julia/bootstrap.py index f4bc726fc..7d63024a6 100644 --- a/julia/bootstrap.py +++ b/julia/bootstrap.py @@ -75,11 +75,11 @@ def main() -> None: "JULIA_CONDAPKG_BACKEND": "Null", "JULIA_PYTHONCALL_EXE": sys.executable, } - # --cuda (--rocm) also prepares the GPU environment, which adds CUDA.jl (AMDGPU.jl) - # to the engine's. + # --cuda (--rocm, --metal) also prepares the GPU environment, which adds CUDA.jl + # (AMDGPU.jl, Metal.jl) to the engine's. projects = ["julia"] + [ f"julia/{gpu}" - for gpu in ("cuda", "rocm") + for gpu in ("cuda", "rocm", "metal") if f"--{gpu}" in sys.argv[1:] or (gpu == "cuda" and "--cuda-local" in sys.argv) ] # --cuda-local: CUDA.jl takes the system toolkit rather than its own, needed where diff --git a/julia/ext/SolpropJuliaMetalExt.jl b/julia/ext/SolpropJuliaMetalExt.jl new file mode 100644 index 000000000..8922bad13 --- /dev/null +++ b/julia/ext/SolpropJuliaMetalExt.jl @@ -0,0 +1,15 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Apple GPUs: the engine's arrays become MtlArrays, its transforms MPSGraph plans and +# its products Metal.jl's; every pass is the same scalar body as on a CPU. Metal has no +# binary64: the engine runs binary32 with the operator's exponents and the Adams flow +# in double-float (dfloat.jl), and refuses anything else at construction. +module SolpropJuliaMetalExt +using Metal +import SolpropJulia + +SolpropJulia.device_backend(::Val{:metal}) = (Metal.allowscalar(false); MetalBackend()) +SolpropJulia.device_label(::MetalBackend) = "metal: " * String(Metal.device().name) + +end diff --git a/julia/metal/LocalPreferences.toml b/julia/metal/LocalPreferences.toml new file mode 100644 index 000000000..4823a80ac --- /dev/null +++ b/julia/metal/LocalPreferences.toml @@ -0,0 +1,3 @@ +# Private GPU storage: a host scalar access is then an error, not a silent slow path. +[Metal] +default_storage = "private" diff --git a/julia/metal/Manifest.toml b/julia/metal/Manifest.toml new file mode 100644 index 000000000..3dae00b7e --- /dev/null +++ b/julia/metal/Manifest.toml @@ -0,0 +1,1074 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "bec50a54d02cbc4fbe06376862b2fccbf112cb33" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AcceleratedKernels]] +deps = ["Adapt", "ArgCheck", "Atomix", "GPUArraysCore", "KernelAbstractions"] +git-tree-sha1 = "ac481710a9eee43b1d8dbd1e26a49a19de71475a" +registries = "General" +uuid = "6a4ca0a5-0e36-4168-a932-d9be78d558f1" +version = "0.5.11" + + [deps.AcceleratedKernels.extensions] + CUDACoreExt = "CUDACore" + MetalExt = "Metal" + OpenCLExt = "OpenCL" + oneAPIExt = "oneAPI" + + [deps.AcceleratedKernels.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "eec8a0ad4e4b673afba213931504c360fffb8f97" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.8.0" + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + + [deps.Adapt.weakdeps] + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +registries = "General" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Atomix]] +deps = ["UnsafeAtomics"] +git-tree-sha1 = "0aa371c875e24cf773c87b2f50ab03e4545748af" +registries = "General" +uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458" +version = "1.7.0" + + [deps.Atomix.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDACore = "bd0ed864-bdfe-4181-a5ed-ce625a5fdea2" + +[[deps.BFloat16s]] +deps = ["LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "59ba860cf4d7e2fe58f35c8d08cfe765b6c33655" +registries = "General" +uuid = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" +version = "0.6.5" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.Bzip2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1b96ea4a01afe0ea4090c5c8039690672dd13f2e" +registries = "General" +uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" +version = "1.0.9+0" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +registries = "General" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CodecBzip2]] +deps = ["Bzip2_jll", "TranscodingStreams"] +git-tree-sha1 = "84990fa864b7f2b4901901ca12736e45ee79068c" +registries = "General" +uuid = "523fee87-0ab8-5b00-afb7-3ecf72e48cfd" +version = "0.8.5" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerCaching]] +deps = ["LMDB", "SHA", "Scratch"] +git-tree-sha1 = "1de3647e392372f1a77e41ae705ceaa12473bc08" +registries = "General" +uuid = "9db33cc3-5358-4881-8759-fa4194144afd" +version = "0.5.3" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CondaPkg]] +deps = ["FileWatching", "JSON", "Markdown", "MicroMamba", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "5105aafa8fedef75ad7f44d7dbf85a1b7196e406" +registries = "General" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.38" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Crayons]] +git-tree-sha1 = "54b76cbb40d9a0f5368c880725b2f141da77c94f" +registries = "General" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.2.0" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.GPUArrays]] +deps = ["AcceleratedKernels", "Adapt", "GPUArraysCore", "KernelAbstractions", "LLVM", "LinearAlgebra", "Printf", "Random", "Reexport", "ScopedValues", "Serialization", "SparseArrays", "Statistics"] +git-tree-sha1 = "1cd2703c11e873a60d0182b6806217a26d71d252" +registries = "General" +uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" +version = "12.2.0" + + [deps.GPUArrays.extensions] + JLD2Ext = "JLD2" + + [deps.GPUArrays.weakdeps] + JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "f60436514e6d73f8ee069ae4ee0ff038fe96b69d" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.2" + +[[deps.GPUCompiler]] +deps = ["CompilerCaching", "ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "REPL", "ScopedValues", "TOML", "Tracy", "UUIDs", "tree_sitter_gcn_jll", "tree_sitter_llvm_jll", "tree_sitter_ptx_jll", "tree_sitter_spirv_jll"] +git-tree-sha1 = "65175d8064f99fc7a27cc9b69bed573b35ee080e" +registries = "General" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "2.21.0" + + [deps.GPUCompiler.extensions] + CthulhuExt = "Cthulhu" + HighlightsExt = "Highlights" + + [deps.GPUCompiler.weakdeps] + AMDGPU_LLVM_Backend_jll = "cc5c0156-bd05-5a77-8a68-bb0aafb29019" + Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f" + Highlights = "eafb193a-b7ab-5a9e-9068-77385905fa72" + LLVMDowngrader_jll = "f52de702-fb25-5922-94ba-81dd59b07444" + NVPTX_LLVM_Backend_jll = "ef6e0fe3-e6ef-59c0-bde6-4989574699e0" + SPIRV_LLVM_Backend_jll = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" + SPIRV_LLVM_Translator_jll = "4a5d46fc-d8cf-5151-a261-86b458210efb" + +[[deps.GPUToolbox]] +git-tree-sha1 = "a380d7a5bf9be3fb1e85344c683bab446f4861c0" +registries = "General" +uuid = "096a3bc2-3ced-46d0-87f4-dd12716f4bfc" +version = "3.5.1" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "06d90f699285d055e34f0b014636a75a17ff2252" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.13.4" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + JSONSerializationExt = ["Serialization"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.KernelAbstractions]] +deps = ["Adapt", "Atomix", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "MacroTools", "PrecompileTools", "Printf", "Random", "Random123", "RandomNumbers", "SPIRVIntrinsics", "SPIRV_LLVM_Backend_jll", "SPIRV_Tools_jll", "StaticArraysCore", "UnsafeAtomics", "pocl_standalone_jll"] +git-tree-sha1 = "0b9e978d21df1aa3ead81c89a2bdf3c6f063a39c" +registries = "General" +uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c" +version = "0.10.5" + + [deps.KernelAbstractions.extensions] + AMDGPUExt = "AMDGPU" + LinearAlgebraExt = "LinearAlgebra" + MetalExt = "Metal" + SparseArraysExt = "SparseArrays" + StaticArraysExt = "StaticArrays" + oneAPIExt = "oneAPI" + + [deps.KernelAbstractions.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b" + +[[deps.KernelInterface]] +git-tree-sha1 = "62300ced3fd046f4694e8dbf0e2fbc2bed84f371" +registries = "General" +uuid = "4ee993da-d684-4d17-a7dd-4e58e78d92bf" +version = "0.4.5" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "PrecompileTools", "Preferences", "Printf", "ScopedValues", "Unicode"] +git-tree-sha1 = "41c2ce7ec5a14c89b93dc6a5853bf2a91d7a8583" +registries = "General" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "10.4.3" +weakdeps = ["BFloat16s"] + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + +[[deps.LLVMDowngrader_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "2db47bc5100d848d977608dbf58fb7ceea1ffa4f" +registries = "General" +uuid = "f52de702-fb25-5922-94ba-81dd59b07444" +version = "0.12.2+0" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML"] +git-tree-sha1 = "39def0b4521e0ef2bf26960d8965729f496bb4ec" +registries = "General" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.56+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LMDB]] +deps = ["CEnum", "LMDB_jll"] +git-tree-sha1 = "84e5cba87693714bfd67f589a91f24a996ff3e69" +registries = "General" +uuid = "11f193de-5e89-5f17-923a-7d207d56daf9" +version = "3.0.1" + +[[deps.LMDB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "196c962b4d66b978b9be1e15e4e1d53441d5f028" +registries = "General" +uuid = "6206cf0b-f360-5984-af49-5437264c140e" +version = "1.0.3+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "f88f3ccef05a6a72a0cf0ed417c8fd68530f4ab2" +registries = "General" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.1" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +registries = "General" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.Metal]] +deps = ["AbstractFFTs", "Adapt", "BFloat16s", "CEnum", "CodecBzip2", "Crayons", "ExprTools", "GPUArrays", "GPUCompiler", "GPUToolbox", "KernelInterface", "LLVM", "LLVMDowngrader_jll", "LinearAlgebra", "ObjectiveC", "PrecompileTools", "Preferences", "PrettyTables", "Printf", "Random", "Random123", "RandomNumbers", "Reexport", "SHA", "ScopedValues", "Statistics", "UUIDs", "UnsafeAtomics"] +git-tree-sha1 = "39e9cec9bc34d25669e34e5cc7cbedb6185445cb" +registries = "General" +uuid = "dde4c033-4e86-420c-a63e-0dd931031962" +version = "1.12.0" + + [deps.Metal.extensions] + KernelAbstractionsExt = "KernelAbstractions" + SpecialFunctionsExt = "SpecialFunctions" + + [deps.Metal.weakdeps] + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +registries = "General" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.ObjectiveC]] +deps = ["CEnum", "Preferences"] +git-tree-sha1 = "fab69a99a059d433330302c23fe088f808263f7e" +registries = "General" +uuid = "e86c9b32-1129-44ac-8ea0-90d5bb39ded9" +version = "7.2.0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "b079a6affebde167dad8ffe0d670b53917fbcb68" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "2.0.3" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools"] +git-tree-sha1 = "e5ae52d1f4f19a9591d615cb0f1ef8d415b40933" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "3.0.6" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "StyledStrings", "Tables"] +git-tree-sha1 = "eeac4c9337f876c3c32b8da732141953567f57c9" +registries = "General" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.5.1" + + [deps.PrettyTables.extensions] + PrettyTablesExcelExt = "XLSX" + PrettyTablesTypstryExt = "Typstry" + PrettyTablesWriteDocxExt = "WriteDocx" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + WriteDocx = "d049ceea-54ee-41d7-a26f-ba29db3b6599" + XLSX = "fdbf4ff8-1666-58a4-91e7-1b58723a45e0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Preferences", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "00d3a883b716a8482da76d08dae1f6084bbfeb23" +registries = "General" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.37" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +registries = "General" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +registries = "General" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEF_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e917bfc9d0aabb490b94bce45c700781ce47c65e" +registries = "General" +uuid = "63e82ce6-3d80-5af4-a84c-484b71ab98bb" +version = "3.9.0+2" + +[[deps.SPIRVIntrinsics]] +deps = ["GPUToolbox", "LLVM", "UnsafeAtomics"] +git-tree-sha1 = "2ee2b6f667d53d1f03079ce7179f7de7ef5058b7" +registries = "General" +uuid = "71d1d633-e7e8-4a92-83a1-de8814b09ba8" +version = "1.6.0" + + [deps.SPIRVIntrinsics.extensions] + SPIRVIntrinsicsSIMDExt = "SIMD" + SPIRVIntrinsicsSIMDSpecialFunctionsExt = ["SIMD", "SpecialFunctions"] + SPIRVIntrinsicsSpecialFunctionsExt = "SpecialFunctions" + + [deps.SPIRVIntrinsics.weakdeps] + GPUCompiler = "61eb1bfa-7361-4325-ad38-22787b887f55" + SIMD = "fdea26ae-647d-5447-a871-4b548cad5224" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SPIRV_LLVM_Backend_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "bbcf46bb8f27f70a2601630c03be93398ab83f7e" +registries = "General" +uuid = "4376b9bf-cff8-51b6-bb48-39421dff0d0c" +version = "23.1.4+2" + +[[deps.SPIRV_Tools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "783c358eff59056d7e703a644f5179270c43226a" +registries = "General" +uuid = "6ac6d60f-d740-5983-97d7-a4482c0689f4" +version = "2025.4.0+0" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SolpropJulia]] +deps = ["AcceleratedKernels", "Atomix", "FFTW", "KernelAbstractions", "LinearAlgebra", "Polyester", "PythonCall"] +path = ".." +uuid = "bc9db228-6fd1-46b1-b175-748485922872" +version = "0.0.0" + + [deps.SolpropJulia.extensions] + SolpropJuliaAMDGPUExt = "AMDGPU" + SolpropJuliaCUDAExt = "CUDA" + SolpropJuliaMetalExt = "Metal" + + [deps.SolpropJulia.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.13.0" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StringManipulation]] +deps = ["PrecompileTools", "StyledStrings"] +git-tree-sha1 = "9e3a02d73a8f0a9be04e677dbef758aab40f8bea" +registries = "General" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.6.1" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "b04bfab37484defe300b2f9ed64469abab2431ff" +registries = "General" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.12.0" + + [deps.StructUtils.extensions] + StructUtilsDBInterfaceExt = ["DBInterface", "Tables"] + StructUtilsDataFramesExt = ["DataFrames"] + StructUtilsLazilyInitializedFieldsExt = ["LazilyInitializedFields"] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazilyInitializedFields = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.10.1+0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +registries = "General" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.TranscodingStreams]] +git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" +registries = "General" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.11.3" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnsafeAtomics]] +deps = ["LLVM"] +git-tree-sha1 = "74ac5e0e702972da953ffc981094617070be582d" +registries = "General" +uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f" +version = "0.4.0" +weakdeps = ["GPUCompiler"] + + [deps.UnsafeAtomics.extensions] + UnsafeAtomicsGPUCompilerExt = "GPUCompiler" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +registries = "General" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +registries = "General" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "56c56fede8f01e1be7e2fdf1eb911487640619a0" +registries = "General" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.76.2+0" + +[[deps.pocl_standalone_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "Libdl", "SLEEF_jll", "Zstd_jll"] +git-tree-sha1 = "1b23d4934878d1f7f66a82257eadd2b899bd2c5b" +registries = "General" +uuid = "54f56a70-6062-5590-a942-1226658f6c83" +version = "7.2.3+7" + +[[deps.tree_sitter_gcn_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7aea9f731552967bda93cb7cbf6925de65bc38d5" +registries = "General" +uuid = "8b5cbfcf-8811-596e-8e87-0e51e05ee4b2" +version = "0.1.0+0" + +[[deps.tree_sitter_llvm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2fb7d0e3a8abf532fa922766ca130bf814df1e70" +registries = "General" +uuid = "44208993-ee63-5069-9443-8e43b04a9b30" +version = "1.1.0+0" + +[[deps.tree_sitter_ptx_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e6ad264eebe3e34f03bca6b5e811d80e0f4797a2" +registries = "General" +uuid = "71e3f6e6-c059-5e7c-a2f2-d560fdad7ce5" +version = "0.1.0+0" + +[[deps.tree_sitter_spirv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7d8c03949bab84b23fe0500d89979e786d54a653" +registries = "General" +uuid = "f0e86581-c468-54df-a4de-3266e11a3c86" +version = "0.1.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/julia/metal/Project.toml b/julia/metal/Project.toml new file mode 100644 index 000000000..14ccc798e --- /dev/null +++ b/julia/metal/Project.toml @@ -0,0 +1,7 @@ +[deps] +Metal = "dde4c033-4e86-420c-a63e-0dd931031962" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +SolpropJulia = "bc9db228-6fd1-46b1-b175-748485922872" + +[sources] +SolpropJulia = {path = ".."} diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index cc317a4d3..c3700d09c 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -35,6 +35,7 @@ mutable struct Engine{C,W} end include("launch.jl") +include("dfloat.jl") include("vmath.jl") include("responses.jl") include("modal.jl") @@ -61,12 +62,18 @@ end function create(input) host = HostInput(input) T = host.has("precision") && host.string("precision") == "single" ? Float32 : Float64 - backend = device_backend(Val(Symbol(host.has("device") ? host.string("device") : "cpu"))) + device = host.has("device") ? host.string("device") : "cpu" + backend = device_backend(Val(Symbol(device))) + # The wide type of the operator's exponents and the Adams flow: binary64, or a + # double-float in a binary32 run that asks for it (an Apple GPU has no binary64). + W = wide_type(T, host.has("wide") ? host.string("wide") : "binary64") + device == "metal" && W === Float64 && + throw(ArgumentError("an Apple GPU has no binary64: metal runs single precision with wide = df32")) # One pool runs everything (launch.jl, `plan`): the libraries' own are single. FFTW.set_num_threads(1) BLAS.set_num_threads(1) c = ( - backend=backend, T=T, tasks=host.int("threads"), scratch=Dict{Any,Any}(), + backend=backend, T=T, wide=zero(W), tasks=host.int("threads"), scratch=Dict{Any,Any}(), fft_threads=host.int("fft_threads"), raman_fft_threads=host.has("raman_fft_threads") ? host.int("raman_fft_threads") : host.int("fft_threads"), transverse_fft_threads=host.has("transverse_fft_threads") ? host.int("transverse_fft_threads") : host.int("fft_threads"), diff --git a/julia/src/adams.jl b/julia/src/adams.jl index d241cdf1a..4c238cf97 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -9,45 +9,75 @@ const RECIP_FACTORIAL = ntuple(k -> 1.0 / factorial(k - 1), 10) const RECIP_INTEGER = ntuple(k -> 1.0 / k, 40) +# The tables in the wide type: binary64's are the engine's original constants, the +# double-float ones the same binary64 values split. +recip_factorial(::Type{Float64}, k) = @inbounds RECIP_FACTORIAL[k] +recip_integer(::Type{Float64}, k) = @inbounds RECIP_INTEGER[k] +const RECIP_FACTORIAL_DF = map(DF32, RECIP_FACTORIAL) +const RECIP_INTEGER_DF = map(DF32, RECIP_INTEGER) +recip_factorial(::Type{DF32}, k) = @inbounds RECIP_FACTORIAL_DF[k] +recip_integer(::Type{DF32}, k) = @inbounds RECIP_INTEGER_DF[k] + +# The size that picks the branch and the halvings: binary64's `abs`, or the high +# parts' modulus in binary32 (the choice needs no more). +phi_size(x::ComplexF64) = abs(x) +phi_size(x::CDF32) = sqrt(real(x).hi * real(x).hi + imag(x).hi * imag(x).hi) +# The series' stop: binary64's squared test as it was; on pairs a one-norm test on the +# high parts, whose squares would be subnormal in binary32 for a small sum. +series_done(term::ComplexF64, total::ComplexF64, stop) = abs2(term) <= stop^2 * abs2(total) +series_done(term::CDF32, total::CDF32, stop) = + abs(real(term).hi) + abs(imag(term).hi) <= stop * (abs(real(total).hi) + abs(imag(total).hi)) +# `value 2^-k`, exactly: binary64's expression as it was, halvings on pairs. +scale_down(value::ComplexF64, k) = value * 0.5^k +scale_down(value::CDF32, k) = halve(value, k) +# k! phi_{k+1}: binary64 divides by the reciprocal, as it did; on pairs the factorial +# (exact in binary32 to 10!) multiplies. +moment_of(value::ComplexF64, k) = value / RECIP_FACTORIAL[k] +moment_of(value::CDF32, k) = value * Float32(factorial(k - 1)) + """`phi_0(x) .. phi_N(x)` by a shifted series and scaling and squaring. -Evaluated in binary64 at either precision: the flow and its moments are rounded once -to the state's precision (SEP 33). Native's `adams_phi` (adams_phi.hpp) is the model: -past |x| = 3 the recurrence from `exp(x)` with one reciprocal of x; below it the series -of `phi_N(y)`, `y = x / 2^s` with |y| <= 1/2, multiplied by the divisors' reciprocals -and stopped once a term is under a quarter ulp of the sum (each later one is smaller -by |y| / (m + N) <= 1/2), then raised back by `s` squarings. +Evaluated in the wide type at either precision (binary64, or a double-float where the +device lacks it): the flow and its moments are rounded once to the state's precision +(SEP 33). Native's `adams_phi` (adams_phi.hpp) is the model: past |x| = 3 the +recurrence from `exp(x)` with one reciprocal of x; below it the series of `phi_N(y)`, +`y = x / 2^s` with |y| <= 1/2, multiplied by the divisors' reciprocals and stopped +once a term is under a quarter ulp of the sum (each later one is smaller by +|y| / (m + N) <= 1/2), then raised back by `s` squarings. In binary64 the operations +are exactly the original ones. """ -@inline function phi_values(x::ComplexF64, ::Val{N}) where {N} - magnitude = abs(x) - out = ntuple(_ -> zero(ComplexF64), Val(N + 1)) - if magnitude > 3.0 +@inline function phi_values(x::Complex{W}, ::Val{N}) where {W,N} + magnitude = phi_size(x) + S = typeof(magnitude) + out = ntuple(_ -> zero(Complex{W}), Val(N + 1)) + if magnitude > S(3) inverse = inv(x) out = Base.setindex(out, exp(x), 1) for k in 1:N - out = Base.setindex(out, (out[k] - RECIP_FACTORIAL[k]) * inverse, k + 1) + out = Base.setindex(out, (out[k] - recip_factorial(W, k)) * inverse, k + 1) end return out end - levels, scale = 0, 1.0 + half = S(0.5) + levels, scale = 0, one(S) reduced = magnitude - while reduced > 0.5 + while reduced > half levels += 1 - scale *= 0.5 - reduced *= 0.5 + scale *= half + reduced *= half end y = scale * x - term = complex(RECIP_FACTORIAL[N+1]) + term = complex(recip_factorial(W, N + 1)) total = term - stop = (0.25 * eps(Float64))^2 + stop = S(0.25) * S(eps(W)) for m in 1:23 - term = term * y * RECIP_INTEGER[m+N] + term = term * y * recip_integer(W, m + N) total += term - abs2(term) <= stop * abs2(total) && break + series_done(term, total, stop) && break end out = Base.setindex(out, total, N + 1) for k in N-1:-1:1 - out = Base.setindex(out, RECIP_FACTORIAL[k+1] + y * out[k+2], k + 1) + out = Base.setindex(out, recip_factorial(W, k + 1) + y * out[k+2], k + 1) end out = Base.setindex(out, exp(y), 1) for _ in 1:levels @@ -56,14 +86,18 @@ by |y| / (m + N) <= 1/2), then raised back by `s` squarings. for k in 1:N value = old[1] * old[k+1] for j in 1:k - value += old[j+1] * RECIP_FACTORIAL[k-j+1] + value += old[j+1] * recip_factorial(W, k - j + 1) end - out = Base.setindex(out, value * 0.5^k, k + 1) + out = Base.setindex(out, scale_down(value, k), k + 1) end end out end phi_snapshot(x, order) = collect(phi_values(ComplexF64(x), Val(Int(order)))) +# The double-float evaluation of the same, widened back for comparison (tests). +phi_snapshot_df(x, order) = + [ComplexF64(Float64(real(v)), Float64(imag(v))) + for v in phi_values(only(widen_host(DF32, [ComplexF64(x)])), Val(Int(order)))] function adams_workspace(c, host, nw, nm) order = host.has("adams_order") ? host.int("adams_order") : 0 @@ -159,7 +193,9 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} (; predictor, corrector, defects, spans, cpredictor, ccorrector, cdefects, slots) = a.device linear, phi, weights, compensated = c.linear, path_terms(w), a.device.rate, a.compensated delta = w.path === nothing ? nothing : w.path.delta_device - step = Float64(h) + # The step in the wide type, split on the host; a kernel body captures values only. + step = wide_value(c, Float64(h)) + xzero = complex(zero(c.wide)) mask = c.norm_mask # The predictor, the flow and its moments, and the state's norm for the scale. active = c.mask @@ -173,9 +209,9 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} compensated && (endpoint[f, m] = 0; error[f, m] = 0) return none end - x = ComplexF64(step * linear[f, m]) + x = step * linear[f, m] if phi !== nothing - x = zero(ComplexF64) + x = xzero for term in axes(phi, 3) x += phi[f, m, term] * delta[term, 7] end @@ -184,7 +220,7 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} forward[f, m, 1] = values[1] predicted = nil for k in 1:N - moment = oftype(nil, values[k+1] / RECIP_FACTORIAL[k]) + moment = oftype(nil, moment_of(values[k+1], k)) moments[f, m, k] = moment if k <= order weighted = nil diff --git a/julia/src/dfloat.jl b/julia/src/dfloat.jl new file mode 100644 index 000000000..ea0115a5c --- /dev/null +++ b/julia/src/dfloat.jl @@ -0,0 +1,205 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# Double-float: a value carried as the unevaluated sum of two binary32s, about 48 +# significand bits. A binary32 run on a device without fast binary64 (an Apple GPU +# has none, an A40 runs it at 1/64 rate) forms the operator's exponents, the +# propagators and the Adams flow in it, and rounds each result once to binary32: the +# precision SEP 33 asks of them (4.1 item 3). The state itself stays binary32. +# +# The primitives are the mlx backend's (src/solprop/backends/mlx_gpu/arithmetic.py), +# whose accuracy SEP 33 measured: Knuth's two-sum, the fused two-product, and complex +# arithmetic on pairs. Every operation here is plain Julia over Float32, so the same +# code runs in a CPU loop, a CUDA kernel or a Metal kernel. Nothing here may be +# reassociated or contracted; Julia does neither without `@fastmath` or `muladd`. + +"""A double-float: `hi + lo` with `|lo| <= ulp(hi) / 2`.""" +struct DF32 <: AbstractFloat + hi::Float32 + lo::Float32 +end + +@inline function two_sum(a::Float32, b::Float32) + s = a + b + bb = s - a + s, (a - (s - bb)) + (b - bb) +end +@inline function quick_two_sum(a::Float32, b::Float32) + s = a + b + s, b - (s - a) +end +@inline function two_prod(a::Float32, b::Float32) + p = a * b + p, fma(a, b, -p) +end + +DF32(x::Float32) = DF32(x, 0.0f0) +DF32(x::DF32) = x +# On the host only: a binary64 value split exactly enough (the pair holds 48 bits). +function DF32(x::Float64) + hi = Float32(x) + DF32(hi, Float32(x - Float64(hi))) +end +# Integers exactly, without binary64: the remainder of the rounded high part. +function DF32(x::Integer) + hi = Float32(x) + DF32(hi, Float32(x - unsafe_trunc(typeof(x), hi))) +end +Base.Float32(x::DF32) = x.hi + x.lo +Base.Float64(x::DF32) = Float64(x.hi) + Float64(x.lo) +Base.promote_rule(::Type{DF32}, ::Type{Float32}) = DF32 +Base.promote_rule(::Type{DF32}, ::Type{<:Integer}) = DF32 + +Base.zero(::Type{DF32}) = DF32(0.0f0, 0.0f0) +Base.one(::Type{DF32}) = DF32(1.0f0, 0.0f0) +Base.zero(::DF32) = zero(DF32) +Base.one(::DF32) = one(DF32) +# The pair's unit roundoff, about 2^-48 (Float32's 24 bits twice). +Base.eps(::Type{DF32}) = DF32(Float32(2.0^-48), 0.0f0) +Base.isnan(x::DF32) = isnan(x.hi) +Base.isinf(x::DF32) = isinf(x.hi) +Base.isfinite(x::DF32) = isfinite(x.hi) +Base.iszero(x::DF32) = iszero(x.hi) +Base.signbit(x::DF32) = signbit(x.hi) + +@inline function Base.:+(x::DF32, y::DF32) + s, e = two_sum(x.hi, y.hi) + DF32(quick_two_sum(s, (e + x.lo) + y.lo)...) +end +@inline Base.:-(x::DF32) = DF32(-x.hi, -x.lo) +@inline Base.:-(x::DF32, y::DF32) = x + (-y) +@inline function Base.:*(x::DF32, y::DF32) + p, e = two_prod(x.hi, y.hi) + DF32(quick_two_sum(p, fma(x.hi, y.lo, fma(x.lo, y.hi, e)))...) +end +# A binary32 factor exactly: the product of the high part and the low part's term. +@inline function Base.:*(x::DF32, y::Float32) + p, e = two_prod(x.hi, y) + DF32(quick_two_sum(p, fma(x.lo, y, e))...) +end +@inline Base.:*(y::Float32, x::DF32) = x * y +@inline function Base.:/(a::DF32, b::Float32) + q1 = a.hi / b + p, e = two_prod(q1, b) + r = ((a.hi - p) - e) + a.lo + DF32(quick_two_sum(q1, r / b)...) +end +@inline function Base.:/(a::DF32, b::DF32) + q1 = a.hi / b.hi + r = a - b * q1 + q2 = r.hi / b.hi + r = r - b * q2 + q3 = r.hi / b.hi + DF32(quick_two_sum(q1, q2)...) + DF32(q3) +end +@inline Base.inv(x::DF32) = one(DF32) / x +@inline Base.abs(x::DF32) = signbit(x.hi) ? -x : x +@inline Base.:<(x::DF32, y::DF32) = x.hi < y.hi || (x.hi == y.hi && x.lo < y.lo) +@inline Base.:<=(x::DF32, y::DF32) = x.hi < y.hi || (x.hi == y.hi && x.lo <= y.lo) +@inline Base.:(==)(x::DF32, y::DF32) = x.hi == y.hi && x.lo == y.lo + +# Complex double-floats: Base's generic `+`, `-`, `*` and `abs2` serve; the division, +# the reciprocal and the exponential are written out, since Base's forms scale through +# `abs`, `floatmin` and binary64 constants. +const CDF32 = Complex{DF32} +@inline function Base.:/(a::CDF32, b::CDF32) + d = real(b) * real(b) + imag(b) * imag(b) + Complex((real(a) * real(b) + imag(a) * imag(b)) / d, + (imag(a) * real(b) - real(a) * imag(b)) / d) +end +@inline Base.inv(b::CDF32) = Complex(one(DF32), zero(DF32)) / b +@inline Base.:/(a::CDF32, b::DF32) = Complex(real(a) / b, imag(a) / b) + +const TWO_PI_DF = DF32(2pi) +const INV_TWO_PI_32 = Float32(1 / 2pi) + +"""A phase less whole turns of a double-float 2 pi, as a double-float: about 2^-48 of +the phase for one of up to 1e7 rad.""" +@inline function reduce_phase(phase::DF32) + turns = round(phase.hi * INV_TWO_PI_32) + phase + TWO_PI_DF * (-turns) +end + +"""`exp(y)` for `|y| <= 1/2`: Horner's form of 18 Taylor terms (a tail below 2^-60).""" +@inline function exp_small(y::CDF32) + e = Complex(one(DF32), zero(DF32)) + for m in 18:-1:1 + p = e * y + e = Complex(real(p) / Float32(m) + one(DF32), imag(p) / Float32(m)) + end + e +end + +"""Scale by `2^-s`, exactly: `s` halvings of both parts.""" +@inline function halve(x::CDF32, s) + for _ in 1:s + x = Complex(real(x) * 0.5f0, imag(x) * 0.5f0) + end + x +end + +"""`exp(x)` in double-float: the phase reduced by whole turns of 2 pi, the argument +halved to at most 1/2, the series, and squared back.""" +@inline function Base.exp(x::CDF32) + r = Complex(real(x), reduce_phase(imag(x))) + size = sqrt(real(r).hi * real(r).hi + imag(r).hi * imag(r).hi) + s = 0 + while size > 0.5f0 + size *= 0.5f0 + s += 1 + end + e = exp_small(halve(r, s)) + for _ in 1:s + e = e * e + end + e +end + +"""`exp(+-z)` rounded once to binary32 each, for a propagator pair. + +With `W = Float64` it is Base's binary64 exponential, as the engine always formed it. +In double-float it is the mlx backend's pair (arithmetic.py, `_PAIR`): the phase +reduced by turns of 2 pi, binary32 cosine and sine of the reduced angle, renormalised +by one Newton step on the double-float squared modulus (binary32 cosine and sine +leave it a few u off one, with a bias a long march accumulates in the energy), and +the magnitude `exp(hi) (1 + lo)`. +""" +@inline wide_exp_pair(z::ComplexF64) = (exp(z), exp(-z)) +@inline function wide_exp_pair(z::CDF32) + re = real(z) + phase = reduce_phase(imag(z)) + angle = phase.hi + phase.lo + c, s = cos(angle), sin(angle) + norm = DF32(two_prod(c, c)...) + DF32(two_prod(s, s)...) + delta = -0.5f0 * ((norm.hi - 1.0f0) + norm.lo) + cc, ss = fma(c, delta, c), fma(s, delta, s) + forward = exp(re.hi) * (1.0f0 + re.lo) + back = exp(-re.hi) * (1.0f0 - re.lo) + (Complex(forward * cc, forward * ss), Complex(back * cc, -(back * ss))) +end +@inline wide_exp(z::ComplexF64) = exp(z) +@inline wide_exp(z::CDF32) = first(wide_exp_pair(z)) + +"""The wide type of a binary32 run: `"binary64"` (the default off Metal) or `"df32"`.""" +function wide_type(T, choice) + T === Float64 && return Float64 + choice == "binary64" && return Float64 + choice == "df32" && return DF32 + throw(ArgumentError("SOLPROP_JULIA_WIDE must be binary64 or df32")) +end + +# The engine's wide type is held as a zero of it (`c.wide`): a type in a named tuple is +# a `DataType` to inference, a value is concrete. +wide_eltype(c) = typeof(c.wide) +"""A host binary64 scalar in the engine's wide type: itself, or split into a pair.""" +wide_value(c, x::Float64) = oftype(c.wide, x) + +"""A host binary64 array in the engine's wide type, for `upload`.""" +widen_host(::Type{Float64}, a::AbstractArray{<:Union{Float64,ComplexF64}}) = a +widen_host(::Type{DF32}, a::AbstractArray{Float64}) = DF32.(a) +widen_host(::Type{DF32}, a::AbstractArray{ComplexF64}) = + [Complex(DF32(real(z)), DF32(imag(z))) for z in a] + +# The double-float propagator pair of a binary64 exponent, widened back (tests). +exp_pair_snapshot_df(z) = + map(ComplexF64, wide_exp_pair(only(widen_host(DF32, [ComplexF64(z)])))) diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index ef66d3a8c..8ffc529df 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -14,12 +14,11 @@ function propagators!(engine, dz) c.cache_propagators && engine.propagator_dz == dz && return nothing (; linear) = c (; forward, inverse) = w - steps = ntuple(s -> dz * c.nodes_c[s], Val(7)) + # Formed on the host in binary64, then split where the wide type is a pair. + steps = ntuple(s -> wide_value(c, dz * c.nodes_c[s]), Val(7)) each!(c, size(linear)...) do f, m @inbounds for s in 1:7 - exponent = steps[s] * linear[f, m] - forward[f, m, s] = exp(exponent) - inverse[f, m, s] = exp(-exponent) + forward[f, m, s], inverse[f, m, s] = wide_exp_pair(steps[s] * linear[f, m]) end end engine.propagator_dz = dz diff --git a/julia/src/free.jl b/julia/src/free.jl index 7ec89e043..39eac4ea5 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -21,15 +21,21 @@ function create_free(c, host) # The separable operator stays binary64 at either precision: the longitudinal root's # compensated subtraction decides its branch near grazing (free_element). R64, C64 = Float64, ComplexF64 - op = ( - k_squared=upload(c, host.array("k_squared", C64)), k_squared_low=upload(c, host.array("k_squared_low", C64)), - kperp_sq=upload(c, host.array("kperp_sq", R64)), kperp_sq_low=upload(c, host.array("kperp_sq_low", R64)), - frame=upload(c, host.array("frame", R64)), spectral_rate=upload(c, host.array("spectral_rate", R64)), - prefactor_numerator=upload(c, host.array("prefactor_numerator", C64)), - prefactor_clamped=upload(c, host.array("prefactor_clamped", C64)), - active=upload(c, host.array("active", Bool)), kperp_rate=upload(c, host.array("kperp_rate", R64)), + separable = ( + k_squared=host.array("k_squared", C64), k_squared_low=host.array("k_squared_low", C64), + kperp_sq=host.array("kperp_sq", R64), kperp_sq_low=host.array("kperp_sq_low", R64), + frame=host.array("frame", R64), spectral_rate=host.array("spectral_rate", R64), + prefactor_numerator=host.array("prefactor_numerator", C64), + prefactor_clamped=host.array("prefactor_clamped", C64), + active=host.array("active", Bool), kperp_rate=host.array("kperp_rate", R64), evanescent_rate=host.real("evanescent_rate"), ) + # In binary64 the tables go to the device and each element is formed where it is + # read. Where the wide type is a double-float, the elements are formed once on the + # host in binary64 (the compensated subtraction and the root need it) and held as + # a rate table in the wide type and a prefactor at the state's precision. + op = wide_eltype(c) === Float64 ? map(v -> v isa Array ? upload(c, v) : v, separable) : + free_tables(c, separable, nw, nm) c = merge(c, ( spatial_shape=shape, op=op, field_scale=T(host.real("pad_scale")) * scale, absorber_scale=T(-0.5) * scale, spatial_rate=upload(c, T.(spatial_rate)), @@ -98,6 +104,23 @@ order: near grazing the residual decides the branch, so no reassociation here. end end +"""The element's rate and prefactor, read from tables formed on the host.""" +@inline free_element(op::NamedTuple{(:rate, :prefactor)}, f, m) = + @inbounds (op.rate[f, m], op.prefactor[f, m]) + +"""Every element's rate (in the wide type) and prefactor (at the state's precision), +formed on the host in binary64 by `free_element` from the separable tables.""" +function free_tables(c, separable, nw, nm) + rate = Matrix{ComplexF64}(undef, nw, nm) + prefactor = Matrix{ComplexF64}(undef, nw, nm) + Threads.@threads for m in 1:nm + for f in 1:nw + rate[f, m], prefactor[f, m] = free_element(separable, f, m) + end + end + (rate=upload(c, widen_host(wide_eltype(c), rate)), prefactor=upload(c, Complex{c.T}.(prefactor))) +end + """Form the propagator pair of one distance in slot one; return the slot.""" function free_propagators!(engine, h) engine.propagator_dz == h && return 1 @@ -107,6 +130,17 @@ function free_propagators!(engine, h) # The zero-distance stage is exactly the identity. fill!(forward, 1) fill!(inverse, 1) + elseif wide_eltype(c) !== Float64 + # The double-float exponent's pair shares one reduced phasor (wide_exp_pair). + # (Names of their own: a captured name assigned in two branches is boxed.) + rates, pair, length = c.op.rate, !c.low_storage, wide_value(c, Float64(h)) + each!(c, size(forward, 1), size(forward, 2)) do f, m + @inbounds begin + there, back = wide_exp_pair(length * rates[f, m]) + forward[f, m, 1] = there + pair && (inverse[f, m, 1] = back) + end + end else op, both, distance = c.op, !c.low_storage, Float64(h) each!(c, size(forward, 1), size(forward, 2)) do f, m diff --git a/julia/src/modal.jl b/julia/src/modal.jl index c22d2ec60..1c19f4a59 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -49,9 +49,10 @@ function create_modal(c, host) # Every inverse transform is unnormalised: its 1/nt is folded into the tables that # read the time-domain field, the synthesis and the in-stage absorber. c = merge(c, (spectral=spectral, spectral_absorber=upload(c, T.(spatial)), - # The operator stays binary64 at either precision: propagators and the Adams - # flow are formed from it in binary64 and rounded once (SEP 33, 4.1 item 3). - linear=upload(c, host.array("linear", ComplexF64)), prefactor=upload(c, host.array("prefactor", C)), + # The operator stays binary64 at either precision, or a double-float where the + # device lacks binary64: propagators and the Adams flow are formed from it in + # that wide type and rounded once (SEP 33, 4.1 item 3). + linear=upload(c, widen_host(wide_eltype(c), host.array("linear", ComplexF64))), prefactor=upload(c, host.array("prefactor", C)), synthesis=upload(c, T.(synthesis ./ nt)), projection=upload(c, host.array("projection", T)), projection_coarse=upload(c, host.array("projection_coarse", T)), embedded=host.flag("embedded"), spatial_absorber=upload(c, T.(spatial ./ nt)), diff --git a/julia/src/stages.jl b/julia/src/stages.jl index f0b8851d1..fedc93a67 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -8,12 +8,12 @@ function path_workspace(c, host) host.has("phi_terms") || return nothing C = Complex{c.T} - # Phi's terms stay binary64, as the operator does (modal.jl). - phi, pre = host.array("phi_terms", ComplexF64), host.array("prefactor_terms", C) + # Phi's terms stay in the wide type, as the operator does (modal.jl). + phi, pre = widen_host(wide_eltype(c), host.array("phi_terms", ComplexF64)), host.array("prefactor_terms", C) stages = 7 (phi=upload(c, phi), prefactor=upload(c, pre), delta=zeros(size(phi, 3), stages), weights=zeros(size(pre, 3), stages), - delta_device=dzeros(c, Float64, size(phi, 3), stages), + delta_device=dzeros(c, wide_eltype(c), size(phi, 3), stages), weights_device=dzeros(c, c.T, size(pre, 3), stages), material=zeros(3, stages), tables=Dict{String,Any}(), constants=zeros(4)) end @@ -24,7 +24,7 @@ function configure_stages!(engine, delta, weights, material) copyto!(p.delta, Matrix{Float64}(delta)) copyto!(p.weights, Matrix{Float64}(weights)) copyto!(p.material, Matrix{Float64}(material)) - copyto!(p.delta_device, p.delta) + copyto!(p.delta_device, widen_host(wide_eltype(engine.config), p.delta)) copyto!(p.weights_device, real_type(engine).(p.weights)) material_stage!(engine, 1) nothing @@ -62,8 +62,7 @@ function path_propagators!(engine) for term in axes(phi, 3) exponent += phi[f, m, term] * delta[term, stage] end - forward[f, m, stage] = exp(exponent) - inverse[f, m, stage] = exp(-exponent) + forward[f, m, stage], inverse[f, m, stage] = wide_exp_pair(exponent) end end end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 13b82e0b4..44ae6dc96 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -118,6 +118,41 @@ def _constant(table: PiecewiseChebyshev | None) -> bool: ) +def _wide(single: bool) -> str: + """Return the wide type of the operator's exponents and the Adams flow. + + A binary64 run forms them in binary64. A binary32 run forms them in binary64 too, + unless ``SOLPROP_JULIA_WIDE=df32`` asks for a double-float (a pair of binary32s, + about 48 bits; ``julia/src/dfloat.jl``). On Metal it is always a double-float, since + an Apple GPU has no binary64. + + Parameters + ---------- + single : bool + Whether the run is in binary32. + + Returns + ------- + str + ``"binary64"`` or ``"df32"``. + + Raises + ------ + BackendError + If the variable names neither, or binary64 on Metal. + """ + metal = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") == "metal" + wide = os.environ.get("SOLPROP_JULIA_WIDE", "df32" if metal else "binary64") + if wide not in {"binary64", "df32"}: + raise BackendError("SOLPROP_JULIA_WIDE must be binary64 or df32") + if metal and wide != "df32": + raise BackendError( + "julia on metal requires SOLPROP_JULIA_WIDE=df32: Apple GPUs have no " + "binary64 arithmetic" + ) + return wide if single else "binary64" + + def _refuse(problem: KernelProblem) -> None: """Refuse unsupported leaves before starting Julia or allocating its state. @@ -180,6 +215,15 @@ def _refuse(problem: KernelProblem) -> None: "non-DOPRI5 tableau": stepper.tableau is not DOPRI5, "interpolated planes": stepper.interpolate_planes, } + if ( + os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") == "metal" + and not problem.precision.single + ): + raise BackendError( + "julia on metal does not support precision='double': Apple GPUs have no " + "binary64 arithmetic" + ) + _wide(problem.precision.single) for reason, refused in reasons.items(): if refused: raise BackendError(f"julia does not support {reason}") @@ -275,6 +319,7 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: factor *= scale**2 config: dict[str, object] = { "precision": "single" if single else "double", + "wide": _wide(single), "state_scale": scale, "adams_order": problem.stepper.integrator.order if isinstance(problem.stepper.integrator, Multistep) @@ -1343,6 +1388,7 @@ def _provenance(self) -> dict[str, object]: "julia_version": str(version), "julia_source_digest": self._digest, "device": str(self._jl.device_name(self._engine)), + "julia_wide": _wide(self._problem.precision.single), "propagator_cache": ( "schedule_run_mean" if self._low_storage is not None diff --git a/src/solprop/backends/julia/_runtime.py b/src/solprop/backends/julia/_runtime.py index c27b29664..77a103df1 100644 --- a/src/solprop/backends/julia/_runtime.py +++ b/src/solprop/backends/julia/_runtime.py @@ -75,7 +75,7 @@ def call_julia(function: Any, *args: object, nogil: bool = False) -> Any: # JuliaCall exposes dynamically compiled Julia modules, so Any is confined to its # boundary. Numerical arrays are converted to owned NumPy arrays by the adapter. -_GPU_PACKAGES = {"cuda": "CUDA", "rocm": "AMDGPU"} +_GPU_PACKAGES = {"cuda": "CUDA", "rocm": "AMDGPU", "metal": "Metal"} """Each GPU device's Julia package, loaded before the engine.""" @@ -86,7 +86,8 @@ def runtime() -> Any: ``SOLPROP_JULIA_EXE`` names the Julia 1.13 executable (default: the one ``julia/bootstrap.py`` downloads), ``SOLPROP_JULIA_DEPOT`` its package depot (default ``.julia-depot``) and ``SOLPROP_JULIA_ROOT`` the checkout (`checkout`). - ``SOLPROP_JULIA_DEVICE=cuda`` (or ``rocm``) loads the CUDA (or AMDGPU) environment, + ``SOLPROP_JULIA_DEVICE=cuda`` (``rocm``, ``metal``) loads the CUDA (AMDGPU, Metal) + environment, so that the engine's GPU extension is available. Returns @@ -116,8 +117,8 @@ def runtime() -> Any: "follow julia/README.md" ) device = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") - if device not in {"cpu", "cuda", "rocm"}: - raise BackendError("SOLPROP_JULIA_DEVICE must be cpu, cuda or rocm") + if device not in {"cpu", *_GPU_PACKAGES}: + raise BackendError("SOLPROP_JULIA_DEVICE must be cpu, cuda, rocm or metal") # A GPU run's environment adds CUDA.jl or AMDGPU.jl to the engine's, resolved # with it, so that a CPU run never resolves or loads the GPU packages. if device != "cpu": @@ -189,6 +190,9 @@ def source_digest() -> str: root / "julia/cuda/Manifest.toml", root / "julia/rocm/Project.toml", root / "julia/rocm/Manifest.toml", + root / "julia/metal/Project.toml", + root / "julia/metal/Manifest.toml", + root / "julia/metal/LocalPreferences.toml", ] ) adapter = sorted(Path(__file__).parent.glob("*.py")) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 7c1be02c6..dda2543eb 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -25,6 +25,11 @@ os.environ.setdefault("PYTHON_JULIACALL_CHECK_BOUNDS", "yes") DEVICE = os.environ.get("SOLPROP_JULIA_DEVICE", "cpu") pytestmark = [pytest.mark.medium] + ([pytest.mark.gpu] if DEVICE != "cpu" else []) +# An Apple GPU has no binary64: on Metal only the binary32 tests run, with the +# operator's exponents and the Adams flow in double-float (julia/src/dfloat.jl). +binary64 = pytest.mark.skipif(DEVICE == "metal", reason="Apple GPUs have no binary64") +# The wide types a binary32 run can form its exponents in on this device. +WIDE = ["df32"] if DEVICE == "metal" else ["binary64", "df32"] @pytest.fixture(scope="module") @@ -80,6 +85,7 @@ def _run(name, configuration): # The Cartesian beam's fused silica is evaluated past Malitson's range, by design of the # benchmark case; the warning says so and is not this test's subject. +@binary64 @pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") @pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS) def test_julia_matches_the_reference(runtime, case, stepper, fraction): @@ -114,6 +120,7 @@ def test_julia_matches_the_reference(runtime, case, stepper, fraction): assert float(np.linalg.norm(field - reference)) <= 1e-10 * scale +@binary64 def test_julia_reports_its_engine(runtime): """Metadata names the runtime and the sources; the ledger counts owned arrays.""" del runtime @@ -131,15 +138,20 @@ def test_julia_reports_its_engine(runtime): @pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.parametrize("wide", WIDE) @pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS[:6]) -def test_julia_single_precision_tracks_the_reference(runtime, case, stepper, fraction): +def test_julia_single_precision_tracks_the_reference( + runtime, monkeypatch, case, stepper, fraction, wide +): """Binary32 (SEP 33) agrees with the binary32 reference on the same contract. A single-precision run's grid is its own, so the reference is numpy_ref's binary32 path, not the binary64 run. The steps may differ: binary32's error estimate is - noisier near rtol's floor. + noisier near rtol's floor. The operator's exponents and the Adams flow are formed + in binary64 or in double-float (``SOLPROP_JULIA_WIDE``), rounded once either way. """ del runtime + monkeypatch.setenv("SOLPROP_JULIA_WIDE", wide) configuration = CASES[case].configuration( stepper, 2, "julia", fraction=fraction, noise="none" ) | {"precision": "single"} @@ -152,6 +164,40 @@ def test_julia_single_precision_tracks_the_reference(runtime, case, stepper, fra assert float(np.linalg.norm(field - reference)) <= 1e-4 * scale +def test_julia_double_float_phi_is_binary64s(runtime): + """The double-float phi functions agree with the binary64 ones to well inside + binary32's rounding, across the series and recurrence branches and a long phase. + + The pair holds about 2^-48; the recurrence past |x| = 3 amplifies an error by up to + about k! / |x|^k (4e-13 relative at order 9 just past the join), and the phase's + reduction keeps about 2^-48 of the phase. 2^-36 bounds both and is still 2^12 + inside the binary32 rounding each value then takes. + """ + generator = np.random.default_rng(5) + radii = np.concatenate([10.0 ** generator.uniform(-6, 0.5, 40), [2.9, 3.1, 30.0]]) + angles = generator.uniform(-np.pi, np.pi, radii.size) + points = [*(radii * np.exp(1j * angles)), -40 + 2e3j, -1e-3 + 1e4j, 0.0] + for order in (1, 3, 6, 9): + for x in points: + exact = np.asarray(runtime.phi_snapshot(complex(x), order)) + pair = np.asarray(runtime.phi_snapshot_df(complex(x), order)) + bound = 2.0**-36 * max(1.0, abs(x.imag)) * np.abs(exact) + 1e-300 + np.testing.assert_array_less(np.abs(pair - exact), bound, err_msg=f"{x} {order}") + + +def test_julia_double_float_propagators_round_once(runtime): + """exp(+-z) by the double-float pair is within a few binary32 ulps of binary64's, + for phases up to 1e6 rad (the mlx backend's measured bound is 5 u).""" + generator = np.random.default_rng(7) + re = generator.uniform(-20, 5, 2000) + im = np.concatenate([generator.uniform(-10, 10, 1000), generator.uniform(-1e6, 1e6, 1000)]) + for z in re + 1j * im: + forward, back = runtime.exp_pair_snapshot_df(complex(z)) + for value, exact in ((forward, np.exp(z)), (back, np.exp(-z))): + assert abs(value - exact) <= 8 * 2.0**-24 * abs(exact), (z, value, exact) + + +@binary64 def test_julia_poynting_statistics_match_the_host(runtime): """The engine's analytic signals give the shared host function's statistics.""" del runtime @@ -184,6 +230,7 @@ def test_julia_poynting_statistics_match_the_host(runtime): engine.close() +@binary64 def test_julia_helpers_are_the_python_forms_bit_for_bit(runtime): """The record's Chebyshev rows and Adams basis equal PLAIN's to the last bit.""" del runtime @@ -218,6 +265,7 @@ def test_julia_helpers_are_the_python_forms_bit_for_bit(runtime): np.testing.assert_array_equal(ours[1], theirs[1]) +@binary64 @pytest.mark.parametrize("compensated", [False, True]) def test_julia_trial_tables_are_the_shared_ones_bit_for_bit(runtime, compensated): """The engine's own trial tables equal backends.multistep.trial_tables'.""" @@ -275,6 +323,7 @@ def test_julia_trial_tables_are_the_shared_ones_bit_for_bit(runtime, compensated ) +@binary64 def test_julia_stage_scalars_are_the_bundles_bit_for_bit(runtime): """The engine's stage scalars, from its own tables, equal scalars_at's. @@ -383,6 +432,7 @@ def _march(configuration, march): return field, record +@binary64 @pytest.mark.parametrize( ("case", "fraction"), [ @@ -410,6 +460,7 @@ def test_julia_march_is_the_python_march(runtime, monkeypatch, case, fraction): np.testing.assert_array_equal(field, reference) +@binary64 @pytest.mark.filterwarnings("ignore::solprop.exceptions.BoundaryWarning") @pytest.mark.parametrize( ("case", "fraction"), [("radial_filament_256", 0.002), ("line", 0.005)] From ecbcafbe83e2babe3bcc56eb63880750722a229d Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 10:35:48 +0000 Subject: [PATCH 061/107] Julia: line lengths in the Metal changes [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- benchmarks/worker.py | 5 ++--- tests/backends/test_julia.py | 8 ++++++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/benchmarks/worker.py b/benchmarks/worker.py index 58c9c3fcc..0860b6fcb 100644 --- a/benchmarks/worker.py +++ b/benchmarks/worker.py @@ -100,9 +100,8 @@ def runtime(backend: str, device: bool = False) -> Record: # are identified by digest, as a native build is by its extension's. # A GPU run takes the GPU the environment names (rocm on AMD), else CUDA. named = os.environ.get("SOLPROP_JULIA_DEVICE") - os.environ["SOLPROP_JULIA_DEVICE"] = ( - (named if named in {"cuda", "rocm", "metal"} else "cuda") if device else "cpu" - ) + gpu = named if named in {"cuda", "rocm", "metal"} else "cuda" + os.environ["SOLPROP_JULIA_DEVICE"] = gpu if device else "cpu" from solprop.backends.julia import source_digest # noqa: PLC0415 info["julia_build"] = source_digest() diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index dda2543eb..70fff2ab7 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -182,7 +182,9 @@ def test_julia_double_float_phi_is_binary64s(runtime): exact = np.asarray(runtime.phi_snapshot(complex(x), order)) pair = np.asarray(runtime.phi_snapshot_df(complex(x), order)) bound = 2.0**-36 * max(1.0, abs(x.imag)) * np.abs(exact) + 1e-300 - np.testing.assert_array_less(np.abs(pair - exact), bound, err_msg=f"{x} {order}") + np.testing.assert_array_less( + np.abs(pair - exact), bound, err_msg=f"{x} {order}" + ) def test_julia_double_float_propagators_round_once(runtime): @@ -190,7 +192,9 @@ def test_julia_double_float_propagators_round_once(runtime): for phases up to 1e6 rad (the mlx backend's measured bound is 5 u).""" generator = np.random.default_rng(7) re = generator.uniform(-20, 5, 2000) - im = np.concatenate([generator.uniform(-10, 10, 1000), generator.uniform(-1e6, 1e6, 1000)]) + im = np.concatenate( + [generator.uniform(-10, 10, 1000), generator.uniform(-1e6, 1e6, 1000)] + ) for z in re + 1j * im: forward, back = runtime.exp_pair_snapshot_df(complex(z)) for value, exact in ((forward, np.exp(z)), (back, np.exp(-z))): From 3f0d33d695745955bac9dc66adb54836051bf18b Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 11:06:52 +0000 Subject: [PATCH 062/107] Julia: contraction in ordinary kernels; a flush-to-zero experiment switch [skip ci] SEP 25 permits fused multiply-adds in ordinary kernels and forbids only umbrella fast-math, approximations and flush-to-zero. The engine now contracts (muladd) the DOPRI and RK4 stage combinations, the Adams predictor and corrector sums, the phi series' recurrence and squarings, the plasma rate's cubic, the FIR sums and the Raman term. The protected helpers (helpers.jl), the march's decisions, the Adams defects, the plasma work defect, the norms and the double-float primitives stay strict. Comments that called the column scan's order or the cubic's rounding required now say which parts are protected and which are choices. Every test passes unchanged (the march and helper bit-for-bit tests included; the windows take numpy_ref's steps). SOLPROP_JULIA_FTZ=1 flushes subnormals to zero in the engine's numerical entry points, for an experiment only (#561): Julia's pool threads for good, and the calling thread (the Python interpreter's own) only for the call's duration, since a flushed subnormal broke solprop's host-side math.log. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/SolpropJulia.jl | 37 +++++++++++++++++++++++--- julia/src/adams.jl | 26 +++++++++--------- julia/src/dopri.jl | 6 ++--- julia/src/march.jl | 2 +- julia/src/responses.jl | 32 +++++++++++++--------- julia/src/rk4.jl | 14 +++++----- src/solprop/backends/julia/_backend.py | 1 + 7 files changed, 78 insertions(+), 40 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index c3700d09c..f431de9ac 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -69,6 +69,9 @@ function create(input) W = wide_type(T, host.has("wide") ? host.string("wide") : "binary64") device == "metal" && W === Float64 && throw(ArgumentError("an Apple GPU has no binary64: metal runs single precision with wide = df32")) + # SOLPROP_JULIA_FTZ=1: flush subnormals to zero in the engine's numerical work (an + # experiment; solprop's policy forbids it, #561). + flush_subnormals!(get(ENV, "SOLPROP_JULIA_FTZ", "0") == "1") # One pool runs everything (launch.jl, `plan`): the libraries' own are single. FFTW.set_num_threads(1) BLAS.set_num_threads(1) @@ -92,6 +95,32 @@ function create(input) engine end +"""Set or clear flush-to-zero (and denormals-are-zero) for the engine's numerical work. + +A CPU's floating-point control register is per thread. Julia's other threads run only +pool tasks, so theirs is set for good; thread one is the Python interpreter's own, +whose NumPy and `math` must keep subnormals (a flushed one made a `math.log` of a +tiny positive value fail), so the entry points set it on entry and restore it on exit +(`flushed`). GPU kernels are unaffected.""" +function flush_subnormals!(on::Bool) + FTZ[] = on + Threads.@threads :static for k in 1:Threads.nthreads() + k == 1 || set_zero_subnormals(on) + end + nothing +end +const FTZ = Ref(false) +@inline function flushed(f::F, args...) where {F} + FTZ[] || return f(args...) + previous = get_zero_subnormals() + set_zero_subnormals(true) + try + f(args...) + finally + set_zero_subnormals(previous) + end +end + """Run each path once on the zero state, then forget it: a GPU's kernels compile at their first launch, which `compile!`'s inference does not reach.""" function warm!(engine) @@ -210,15 +239,15 @@ end device_name(engine) = device_label(engine.config.backend) runtime() = (string(VERSION), Threads.nthreads(), FFTW.get_num_threads(), BLAS.get_num_threads(), string(BLAS.get_config())) -const rk4_b = rk4! +rk4_b(args...) = flushed(rk4!, args...) const configure_stages_b = configure_stages! const load_b = load! const bind_monitor_b = bind_monitor! const copy_state_b = copy_state! const bind_edge_b = bind_edge! -const trial_b = trial! -const commit_b = commit! -const evaluate_b = evaluate! +trial_b(args...) = flushed(trial!, args...) +commit_b(args...) = flushed(commit!, args...) +evaluate_b(args...) = flushed(evaluate!, args...) const reset_work_b = reset_work! diff --git a/julia/src/adams.jl b/julia/src/adams.jl index 4c238cf97..0b5f23de6 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -77,7 +77,7 @@ are exactly the original ones. end out = Base.setindex(out, total, N + 1) for k in N-1:-1:1 - out = Base.setindex(out, recip_factorial(W, k + 1) + y * out[k+2], k + 1) + out = Base.setindex(out, muladd(y, out[k+2], recip_factorial(W, k + 1)), k + 1) end out = Base.setindex(out, exp(y), 1) for _ in 1:levels @@ -86,7 +86,7 @@ are exactly the original ones. for k in 1:N value = old[1] * old[k+1] for j in 1:k - value += old[j+1] * recip_factorial(W, k - j + 1) + value = muladd(old[j+1], recip_factorial(W, k - j + 1), value) end out = Base.setindex(out, scale_down(value, k), k + 1) end @@ -225,9 +225,9 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} if k <= order weighted = nil for j in 1:order - weighted += predictor[j, k] * store[f, m, slots[j]] + weighted = muladd(predictor[j, k], store[f, m, slots[j]], weighted) end - predicted += moment * weighted + predicted = muladd(moment, weighted, predicted) end end if compensated @@ -236,12 +236,12 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} slot = slots[j] value = oftype(nil, exp(spans[j] * x)) * (rates[f, m, slot] - oftype(nil, x / step)) * states[f, m, slot] carried[f, m, j] = value - j <= order && (correction += cpredictor[j] * value) + j <= order && (correction = muladd(cpredictor[j], value, correction)) end predicted += correction error[f, m] = adams_rate(linear, phi, weights, f, m) end - value = oftype(nil, values[1]) * y[f, m] + h * predicted + value = muladd(h, predicted, oftype(nil, values[1]) * y[f, m]) lab[f, m] = value compensated && (endpoint[f, m] = (error[f, m] - oftype(nil, x / step)) * value) mask[f] ? abs2(y[f, m]) : none @@ -262,18 +262,18 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} for k in 1:N weighted = corrector[1, k] * source[f, m] for j in 2:N - weighted += corrector[j, k] * store[f, m, slots[j-1]] + weighted = muladd(corrector[j, k], store[f, m, slots[j-1]], weighted) end - corrected += moments[f, m, k] * weighted + corrected = muladd(moments[f, m, k], weighted, corrected) end if compensated correction = ccorrector[1] * endpoint[f, m] for j in 1:order - correction += ccorrector[j+1] * carried[f, m, j] + correction = muladd(ccorrector[j+1], carried[f, m, j], correction) end corrected += correction end - candidate[f, m] = forward[f, m, 1] * y[f, m] + h * corrected + candidate[f, m] = muladd(h, corrected, forward[f, m, 1] * y[f, m]) result = zero3 if mask[f] scale = relative * weight[f] + absolute @@ -323,7 +323,7 @@ function adams_load_rows!(engine, name, rows) end const configure_adams_b = configure_adams! const configure_adams_rate_b = configure_adams_rate! -const adams_start_b = adams_start! -const adams_trial_b = adams_trial! -const adams_accept_b = adams_accept! +adams_start_b(args...) = flushed(adams_start!, args...) +adams_trial_b(args...) = flushed(adams_trial!, args...) +adams_accept_b(args...) = flushed(adams_accept!, args...) const adams_load_rows_b = adams_load_rows! diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 8ffc529df..9f1c8a60b 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -52,7 +52,7 @@ function trial!(engine, dz::Float64) @inbounds begin combination = zero(eltype(y)) for p in 1:stage-1 - combination += row[p] * stages[f, m, p] + combination = muladd(row[p], stages[f, m, p], combination) end lab[f, m] = forward[f, m, slot] * (y[f, m] + combination) end @@ -84,8 +84,8 @@ function combine!(engine, dz, slot) solution, defect = zero(eltype(y)), zero(eltype(y)) for s in 1:7 value = stages[f, m, s] - solution += b[s] * value - defect += e[s] * value + solution = muladd(b[s], value, solution) + defect = muladd(e[s], value, defect) end flow = forward[f, m, slot] new = flow * (y[f, m] + solution) diff --git a/julia/src/march.jl b/julia/src/march.jl index 49c549c71..51a41cabd 100644 --- a/julia/src/march.jl +++ b/julia/src/march.jl @@ -448,4 +448,4 @@ for T in (Int,) end const configure_march_b = configure_march! -const march_run_b = march_run! +march_run_b(args...) = flushed(march_run!, args...) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index a4f0cb760..96f8f647f 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -26,7 +26,7 @@ function nonlinear_nodes!(nodes, values, c, factor, raman, count) each!(c, size(nodes, 1), count) do t, m @inbounds begin v = nodes[t, m] - nodes[t, m] = (polarization(values[t, m], f, a) + r * v * drive[t, m]) * window[t] + nodes[t, m] = muladd(r * v, drive[t, m], polarization(values[t, m], f, a)) * window[t] end end end @@ -44,7 +44,7 @@ function nonlinear_envelope!(nodes, c, factor, raman, count) v = nodes[t, m] response = f * abs2(v) * v if live - response += r * v * real(drive[t, m]) + response = muladd(r * v, real(drive[t, m]), response) end nodes[t, m] = response * window[t] end @@ -114,7 +114,8 @@ end @noinline function live_rates!(scratch, knots, node, count, table, cap, origin, step) last = Int32(size(table, 2)) # The logarithm, then each sample's knot and its distance past it, vectorised; only - # the table's four loads and the cubic stay scalar (`log_rate`'s values, bit for bit). + # the table's four loads and the cubic stay scalar (`log_rate`'s cubic, contracted + # the same way, so the two paths agree). @inbounds @simd for i in 1:count logarithm = vlog(scratch[i, node]) j = clamp(unsafe_trunc(Int32, floor((logarithm - origin) / step)) + Int32(1), @@ -124,7 +125,7 @@ end end @inbounds for i in 1:count j, s = knots[i, node], scratch[i, node] - scratch[i, node] = ((table[1, j] * s + table[2, j]) * s + table[3, j]) * s + table[4, j] + scratch[i, node] = cubic(table, j, s) end @inbounds @simd for i in 1:count scratch[i, node] = min(vexp(scratch[i, node]), cap) @@ -186,35 +187,41 @@ end @inline function log_rate(logarithm, table, origin, step) j = clamp(unsafe_trunc(Int, floor((logarithm - origin) / step)) + 1, 1, size(table, 2)) s = logarithm - (origin + (j - 1) * step) - @inbounds ((table[1, j] * s + table[2, j]) * s + table[3, j]) * s + table[4, j] + cubic(table, j, s) end +"""Knot `j`'s cubic at `s` by Horner's rule, contracted (SEP 25 permits fused +multiply-adds in an ordinary kernel).""" +@inline cubic(table, j, s) = + @inbounds muladd(muladd(muladd(table[1, j], s, table[2, j]), s, table[3, j]), s, table[4, j]) @inline rate_arguments(p) = (p.field_scale, p.coefficients, ntuple(k -> typeof(p.dt)(p.parameters[k]), 5)...) """The rate at a scaled field's physical value `s E`: exact, s a power of two.""" @inline scaled_rate(value, scale, args...) = rate_value(scale * value, args...) # A symmetric FIR, reflected at the ends as RunningIntegral is, then a running -# trapezoid. The scan's order is strict: no reassociation. +# trapezoid. The scan runs in order on a CPU; that is a choice, not policy: SEP 25 (5, +# item 5) permits a reassociated or segmented scan within its prefix's rounding bound, +# as the GPU's column scans are. The sums contract. @inline function filtered(values, t, node, taps) nt = size(values, 1) @inbounds value = taps[1] * values[t, node] @inbounds for k in 1:length(taps)-1 left = t - k < 1 ? 2 * values[1, node] - values[1+k-t+1, node] : values[t-k, node] right = t + k > nt ? 2 * values[nt, node] - values[2nt-t-k, node] : values[t+k, node] - value += taps[k+1] * (left + right) + value = muladd(taps[k+1], left + right, value) end value end """The interior samples' FIR, one pass: each sample's sum in the order the taps give it -(the centre, then each pair), as the tap-at-a-time passes formed it, bit for bit, with -a fifth of their memory traffic. The taps are a tuple, so the sum unrolls and the -samples vectorise.""" +(the centre, then each pair), contracted as `filtered` contracts it, with a fifth of +the tap-at-a-time passes' memory traffic. The taps are a tuple, so the sum unrolls and +the samples vectorise.""" @noinline function fir_interior!(out, values, node, first, last, taps::NTuple{N}) where {N} @inbounds @simd for t in first:last value = taps[1] * values[t, node] for k in 1:N-1 - value += taps[k+1] * (values[t-k, node] + values[t+k, node]) + value = muladd(taps[k+1], values[t-k, node] + values[t+k, node], value) end out[t, node] = value end @@ -499,7 +506,8 @@ function population_columns!(p, nodes, c, first, count) if t == 1 start = value else - # The diagnostic's trapezoid is ordered and strict, like the prefix. + # The diagnostic's trapezoid stays ordered and uncontracted: it is a + # defect, a difference of nearly equal sums (strict by SEP 25). paid += dt * (product + product_before) / 2 end product_before = product diff --git a/julia/src/rk4.jl b/julia/src/rk4.jl index 90840fc17..a3a0455cb 100644 --- a/julia/src/rk4.jl +++ b/julia/src/rk4.jl @@ -20,8 +20,8 @@ function rk4!(engine, dz::Float64, key::Float64) y[f, m] *= flow slope = flow * source[f, m] error[f, m] = slope - candidate[f, m] = y[f, m] + sixth * slope - lab[f, m] = y[f, m] + half * slope + candidate[f, m] = muladd(sixth, slope, y[f, m]) + lab[f, m] = muladd(half, slope, y[f, m]) end end source!(engine, lab) @@ -31,8 +31,8 @@ function rk4!(engine, dz::Float64, key::Float64) difference = slope - error[f, m] # The second slope is the third's reference: kept where the first was. error[f, m] = slope - candidate[f, m] += third * slope - lab[f, m] = y[f, m] + half * slope + candidate[f, m] = muladd(third, slope, candidate[f, m]) + lab[f, m] = muladd(half, slope, y[f, m]) mask[f] ? abs2(difference) : none end end @@ -42,15 +42,15 @@ function rk4!(engine, dz::Float64, key::Float64) slope = source[f, m] difference = slope - error[f, m] error[f, m] = difference - candidate[f, m] += third * slope - lab[f, m] = forward[f, m, 1] * (y[f, m] + h * slope) + candidate[f, m] = muladd(third, slope, candidate[f, m]) + lab[f, m] = forward[f, m, 1] * muladd(h, slope, y[f, m]) mask[f] ? abs2(difference) : none end end source!(engine, lab) squared = reduce_each(+, none, c, size(y)...) do f, m @inbounds begin - new = forward[f, m, 1] * candidate[f, m] + sixth * source[f, m] + new = muladd(sixth, source[f, m], forward[f, m, 1] * candidate[f, m]) candidate[f, m] = new mask[f] ? abs2(new) : none end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 44ae6dc96..5bc56183b 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -1389,6 +1389,7 @@ def _provenance(self) -> dict[str, object]: "julia_source_digest": self._digest, "device": str(self._jl.device_name(self._engine)), "julia_wide": _wide(self._problem.precision.single), + "julia_flush_subnormals": os.environ.get("SOLPROP_JULIA_FTZ", "0") == "1", "propagator_cache": ( "schedule_run_mean" if self._low_storage is not None From e99851d542a70867b20b8a541afd16bfc4120201 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 12:05:40 +0000 Subject: [PATCH 063/107] Julia: SOLPROP_JULIA_BLAS=accelerate, Apple's BLAS for the products (an experiment) [skip ci] Forwards libblastrampoline to Accelerate's new LP64 and ILP64 interfaces with OpenBLAS beneath, as AppleAccelerate.jl does, and sets Accelerate single-threaded since the engine's pool splits its products. The binary64 and binary32 windows pass against numpy_ref with it. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/SolpropJulia.jl | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index f431de9ac..b1c684069 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -72,6 +72,8 @@ function create(input) # SOLPROP_JULIA_FTZ=1: flush subnormals to zero in the engine's numerical work (an # experiment; solprop's policy forbids it, #561). flush_subnormals!(get(ENV, "SOLPROP_JULIA_FTZ", "0") == "1") + # SOLPROP_JULIA_BLAS=accelerate: Apple's Accelerate for the products (an experiment). + get(ENV, "SOLPROP_JULIA_BLAS", "openblas") == "accelerate" && use_accelerate!() # One pool runs everything (launch.jl, `plan`): the libraries' own are single. FFTW.set_num_threads(1) BLAS.set_num_threads(1) @@ -95,6 +97,22 @@ function create(input) engine end +const ACCELERATE = "/System/Library/Frameworks/Accelerate.framework/Accelerate" +"""Forward libblastrampoline's BLAS and LAPACK to Accelerate's new interfaces (macOS 13.4 +and later), LP64 and ILP64, keeping OpenBLAS beneath for what Accelerate lacks, as +AppleAccelerate.jl does (the `\x1a` marks an exact suffix); then set Accelerate +single-threaded (macOS 15 and later), since the engine's pool already splits its +products into blocks of rows (`gemm!`). Return the configuration.""" +function use_accelerate!() + Sys.isapple() || throw(ArgumentError("SOLPROP_JULIA_BLAS=accelerate needs macOS")) + BLAS.lbt_forward(ACCELERATE; suffix_hint="\x1a\$NEWLAPACK") + BLAS.lbt_forward(ACCELERATE; suffix_hint="\x1a\$NEWLAPACK\$ILP64") + # BLASSetThreading(BLAS_THREADING_SINGLE_THREADED = 1) returns 0 on success. + ccall((:BLASSetThreading, ACCELERATE), Cint, (Cint,), 1) == 0 || + throw(ErrorException("Accelerate's BLASSetThreading failed")) + BLAS.get_config() +end + """Set or clear flush-to-zero (and denormals-are-zero) for the engine's numerical work. A CPU's floating-point control register is per thread. Julia's other threads run only From d872cb599cbebd54bb4a077f077aa420b67d04b2 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 13:09:18 +0000 Subject: [PATCH 064/107] Julia: Accelerate by default on macOS; benchmarks ab --cooldown [skip ci] Accelerate against OpenBLAS on the M5 Max (2 % windows, 1 and 6 threads, three rounds): radial 0.59 and 0.82, h2 0.88 on 6 threads, no row slower beyond its rounds' spread, the same steps. SOLPROP_JULIA_BLAS=openblas keeps OpenBLAS. --cooldown idles before each worker: a heavy process (a Julia worker's compilation, or 15 s of every core busy) slowed the next native window on the Mac by 20 to 80 %, with no thermal warning recorded. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- benchmarks/ab.py | 9 ++++++++ docs/dev/benchmarks.md | 47 +++++++++++++++++++++++++++++++++++++++ julia/README.md | 2 ++ julia/src/SolpropJulia.jl | 8 +++++-- 4 files changed, 64 insertions(+), 2 deletions(-) diff --git a/benchmarks/ab.py b/benchmarks/ab.py index 4dab9c73b..9bf0923d4 100644 --- a/benchmarks/ab.py +++ b/benchmarks/ab.py @@ -77,6 +77,13 @@ def ab_options(parser: argparse.ArgumentParser) -> None: choices=BACKENDS, help="the candidate arm's backend; default: --backend", ) + parser.add_argument( + "--cooldown", + type=float, + default=0.0, + help="seconds to idle before each worker, so that one worker's heat (a Julia " + "worker's compilation) does not slow the next", + ) parser.add_argument( "--device-arm", choices=("baseline", "candidate"), @@ -275,6 +282,8 @@ def ab(args: argparse.Namespace) -> int: for row in shuffled: width = row["configuration"]["threads"] for arm in arm_order(round_index): + if args.cooldown > 0: + time.sleep(args.cooldown) quiet = guard(allocation)["quiet"] events, elapsed = launch_worker( pythons[arm], diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 95baee386..9c9085985 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3070,3 +3070,50 @@ Geometric means 2.48 (binary64) and 2.62 (binary32 against native's binary64). A statistics' sums, the monitor's row and column sums) and the occupancy's atomics on a crossing's few buckets the largest kernels; commit `50158fa6` forms them as device reductions. + +**Apple M5 Max** (6 top-tier and 12 second-tier cores, 128 GB, macOS 27; native built on +the NEON FFTW 3.3.11 prefix with Accelerate's BLAS), three rounds on a quiet machine, +commit `3933d4f3` (the engine as measured above; Julia's BLAS is OpenBLAS). The first +measurement of the rewritten engine on this machine: + +| case | native 1 thread, s | julia | ratio | native 6, s | julia | ratio | native 18, s | julia | ratio | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.196 | 0.222 | 1.17 | 0.085 | 0.072 | 0.88 | 0.110 | 0.067 | 0.61 | +| `argon_blueshift` | 0.355 | 0.303 | 0.86 | 0.134 | 0.106 | 0.79 | 0.135 | 0.114 | 0.86 | +| `h2_raman_6ps` | 1.433 | 1.478 | 1.03 | 0.804 | 0.653 | 0.81 | 1.038 | 0.925 | 0.82 | +| `ctc_reduced` | 0.669 | 0.573 | 0.84 | 0.207 | 0.158 | 0.76 | 0.214 | 0.163 | 0.76 | +| `radial_filament_256` | 0.914 | 1.030 | 1.12 | 0.322 | 0.291 | 0.90 | 0.302 | 0.260 | 0.86 | +| `kerr_beam_192` | 1.662 | 1.555 | 0.92 | 0.528 | 0.475 | 0.90 | 0.443 | 0.337 | 0.76 | +| `line` | 0.219 | 0.266 | 1.23 | 0.114 | 0.078 | 0.68 | 0.183 | 0.070 | 0.38 | + +Geometric mean 0.83: Julia faster in 16 of 21 rows, every row on native's steps with +fields equal to 1e-13 or better. Native is slower on 18 threads than on 6 in four +cases (`h2_raman_6ps` 0.80 -> 1.04 s, `line` 0.11 -> 0.18 s, `rdw`, `ctc_reduced`): the +second-tier cores hold back its parallel regions. Julia's tasks lose less there. + +**Apple M5 Max GPU** (40 cores, Metal 4; Metal.jl 1.12), `julia` in binary32 with +`SOLPROP_JULIA_DEVICE=metal` and the double-float wide type (`julia/src/dfloat.jl`), +commit `ecbcafbe`, `--device-arm candidate`. Against native's binary64 on 6 CPU threads, +three rounds, the cases' own transform sizes; and against `mlx` (binary32, +`MLX_ENABLE_TF32=0`), two rounds, `--fft-size pow2`: + +| case | native 6 threads, s | julia Metal, s | ratio | mlx, s | julia Metal, s | ratio | +|---|---:|---:|---:|---:|---:|---:| +| `rdw` | 0.091 | 0.359 | 3.95 | 0.453 | 0.523 | 1.16 | +| `argon_blueshift` | 0.137 | 0.868 | 6.35 | 0.530 | 0.890 | 1.68 | +| `h2_raman_6ps` | 0.797 | 1.574 | 1.97 | 0.916 | 1.939 | 2.12 | +| `ctc_reduced` | 0.213 | 0.723 | 3.42 | 1.115 | 1.062 | 0.96 | +| `radial_filament_256` | 0.306 | 0.278 | 0.92 | 0.318 | 0.271 | 0.96 | +| `kerr_beam_192` | 0.539 | 0.176 | 0.33 | 0.286 | 0.200 | 0.71 | +| `line` | 0.112 | 0.231 | 2.09 | 0.134 | 0.241 | 1.80 | + +Geometric means 1.95 against native's CPU and 1.25 against `mlx`. The binary32 fields +are 4e-7 to 2e-5 from native's binary64 and 1e-6 to 2e-5 from `mlx`'s. The GPU wins +where the state is large (the Cartesian beam three times native's six cores, radial at +par) and loses where it is a capillary's few modes, whose windows are launch-bound; +`argon_blueshift`'s plasma takes the per-sample GPU path. Metal.jl's probes on this GPU: +every FFT plan form the engine uses (in-place, dimension 1 of a matrix, odd `brfft`, +dims (2, 3)) works, without MLX's Bluestein cliff (10240 points as fast as 8192), at +2 to 5e-7; Float32 GEMM is full precision (1.5e-7, not TF32) on real views; the +two-sum and fused two-product survive compilation. Construction compiles the Metal +kernels: about 28 s, with no precompiled trace for the device yet. diff --git a/julia/README.md b/julia/README.md index 8064f43d6..accf7c5f9 100644 --- a/julia/README.md +++ b/julia/README.md @@ -48,6 +48,8 @@ solprop is installed without `-e`. A run then takes `backend="julia"`: |---|---| | `SOLPROP_JULIA_THREADS` | the engine's threads (default 1); the benchmark harness sets it to the width | | `SOLPROP_JULIA_DEVICE` | `cpu` (default), `cuda`, `rocm` or `metal`, which load `julia/cuda`, `julia/rocm` or `julia/metal`: CUDA.jl, AMDGPU.jl or Metal.jl resolved with the engine. `metal` runs `precision="single"` only | +| `SOLPROP_JULIA_BLAS` | `accelerate` (default on macOS: Apple's BLAS, OpenBLAS beneath) or `openblas` (default elsewhere) | +| `SOLPROP_JULIA_FTZ` | `1`: flush subnormals to zero in the engine's numerical calls (an experiment; solprop's policy forbids it, #561) | | `SOLPROP_JULIA_WIDE` | a binary32 run's wide type for the operator's exponents, the propagators and the Adams flow: `binary64` (default) or `df32` (double-float, `src/dfloat.jl`); `metal` always uses `df32`. Binary64 runs ignore it | | `SOLPROP_JULIA_MARCH` | `host`: the Python Adams march in place of the engine's (`src/march.jl`) | | `SOLPROP_FFTW_PLAN` | `estimate`, `measure` (default) or `patient` | diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index b1c684069..943271bf1 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -72,8 +72,12 @@ function create(input) # SOLPROP_JULIA_FTZ=1: flush subnormals to zero in the engine's numerical work (an # experiment; solprop's policy forbids it, #561). flush_subnormals!(get(ENV, "SOLPROP_JULIA_FTZ", "0") == "1") - # SOLPROP_JULIA_BLAS=accelerate: Apple's Accelerate for the products (an experiment). - get(ENV, "SOLPROP_JULIA_BLAS", "openblas") == "accelerate" && use_accelerate!() + # Apple's Accelerate for the products on macOS (SOLPROP_JULIA_BLAS=openblas keeps + # OpenBLAS): radial's window on one M5 Max thread 1.02 s -> 0.60 s, no case slower. + blas = get(ENV, "SOLPROP_JULIA_BLAS", Sys.isapple() ? "accelerate" : "openblas") + blas in ("accelerate", "openblas") || + throw(ArgumentError("SOLPROP_JULIA_BLAS must be accelerate or openblas")) + blas == "accelerate" && use_accelerate!() # One pool runs everything (launch.jl, `plan`): the libraries' own are single. FFTW.set_num_threads(1) BLAS.set_num_threads(1) From 6554012cbdde6684e07de066c4c9c21464d1d088 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 13:20:40 +0000 Subject: [PATCH 065/107] Julia: the M5 Max, Metal, floating-point and A40 rows; toward a first-class backend [skip ci] The ledger's Julia section gains the M5 Max CPU rows (0.83 over native's windows, 0.82 over whole runs), the Metal rows (1.95 against native's six CPU threads, 1.25 against mlx), Accelerate (0.94), contraction (0.99), flush-to-zero (no gain on the M5 Max or the Xeon), native's thread scan on the M5 Max, the machine-state effect between workers, and the A40's df32 rows (0.99 against the binary64 wide type, 1.72 against native). STATUS.md records them, corrects the subnormal explanation of slow binary32 on x86 (flushing changed nothing), and adds an assessment of Julia as a first-class backend. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 56 +++++++++++++++++++++ julia/METAL_HANDOFF.md | 6 +++ julia/STATUS.md | 109 +++++++++++++++++++++++++++++++++++++++-- 3 files changed, 166 insertions(+), 5 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 9c9085985..dea2cb5d2 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3117,3 +3117,59 @@ dims (2, 3)) works, without MLX's Bluestein cliff (10240 points as fast as 8192) 2 to 5e-7; Float32 GEMM is full precision (1.5e-7, not TF32) on real views; the two-sum and fused two-product survive compilation. Construction compiles the Metal kernels: about 28 s, with no precompiled trace for the device yet. + +The same M5 Max, later commits: + +- **Whole runs** (commit `3f0d33d6`, the full guides, 6 threads, two rounds): `julia` over + native 0.86 (`rdw`, 2.33 s native), 0.74 (`argon_blueshift`, 5.69 s), 0.95 (radial, + 0.94 s), 1.02 (`kerr_beam_192`, 1.59 s), 0.71 (`ctc_reduced`, 6.12 s), 0.82 + (`h2_raman_6ps`, 63.2 s) and 0.68 (`line`, 0.14 s); geometric mean 0.82, every round + within 0.3 %, the same steps, fields 1e-11 to 1e-15 apart. +- **Accelerate for Julia's products** (`SOLPROP_JULIA_BLAS=accelerate` against + OpenBLAS 0.3.30, commit `e99851d5`, three rounds): radial 0.59 on one thread and 0.82 + on six, `h2_raman_6ps` 0.88 on six, every other row 0.97 to 1.05 within its rounds' + spread; geometric mean 0.94. Commit `d872cb59` makes it the default on macOS. +- **Contraction** (commit `3f0d33d6`'s fused multiply-adds against `ecbcafbe`, binary64, + three rounds): geometric mean 0.99, `h2_raman_6ps` 0.96 and 0.93 the only steady gain; + fields 1e-13 apart, the same steps. +- **Flush-to-zero** (`SOLPROP_JULIA_FTZ=1`, an experiment the policy forbids, #561): + binary32 0.997 and binary64 0.99, nothing beyond the rounds' spread but + `ctc_reduced` on six threads (0.88). Apple's cores take subnormals at full speed. +- **Native's thread count.** Native's 2 % windows on 1 to 18 threads (OpenMP default + and `active` waiting alike) are fastest on the six top-tier cores for `rdw`, radial, + `h2_raman_6ps` and `line`, and on 12 for `kerr_beam_192` and `ctc_reduced`; eight + threads, two of them second-tier, are already slower than six, and 18 take 1.4 to 1.5 + times six's time (`h2_raman_6ps` 0.61 -> 0.91 s). +- **The machine's state between workers.** Native's six-thread windows ran 10 to 80 % + slower right after a heavy process than in a run of native workers alone (`rdw` + 0.062 s alone, 0.083 s after Julia workers, 0.092 s after 15 s of every core busy; + `line` 0.067, 0.119 and 0.123 s), with no thermal warning recorded. A Julia worker + compiles for 7 to 30 s before its window, so every native-against-Julia A/B above + ran both arms in that state: the ratios hold, the absolute times are slow. Commit + `d872cb59` adds `benchmarks ab --cooldown`. + +**NVIDIA A40** (DMOG, driver 595.71), commit `ecbcafbe`, `--device`: the device tests +pass (34, binary32 in both wide types). `julia` binary32 with the double-float wide +type against binary64, three rounds: geometric mean 0.99, the free-space rows 0.88 +(`kerr_beam_192`) and 0.91 (`line`) from forming the operator's elements once on the +host, the rest within their rounds. Against native's CUDA build (binary64), two rounds: + +| case | native, s | julia binary32 df32, s | ratio | +|---|---:|---:|---:| +| `rdw` | 0.054 | 0.230 | 4.26 | +| `argon_blueshift` | 0.116 | 0.254 | 2.19 | +| `h2_raman_6ps` | 1.042 | 0.644 | 0.62 | +| `ctc_reduced` | 0.207 | 0.285 | 1.38 | +| `radial_filament_256` | 0.169 | 0.246 | 1.46 | +| `kerr_beam_192` | 0.174 | 0.488 | 2.80 | +| `line` | 0.094 | 0.127 | 1.35 | + +Geometric mean 1.72 (1.99 for binary32 in the binary64 wide type at `50158fa6`): the +A40's slow binary64 in the operator and phi functions was not what held binary32 back. + +**Intel Xeon Gold 6240** (16 cores of a socket, exclusive), flush-to-zero in binary32, +commit `3f0d33d6`, three rounds: geometric mean 0.99, every row within its rounds' +spread on one thread and on 16 (radial 0.89 on 16 the largest move). The binary32 +windows here take 2 to 3 times binary64's (`rdw` on one thread 1.43 s, 0.63 s in +binary64 at `a6722029`), and flushing subnormals does not change that: they are not +the cause. diff --git a/julia/METAL_HANDOFF.md b/julia/METAL_HANDOFF.md index a696837f9..02f0368d9 100644 --- a/julia/METAL_HANDOFF.md +++ b/julia/METAL_HANDOFF.md @@ -1,5 +1,11 @@ # Handoff: the Julia backend on a Mac (CPU comparison, then Metal) +> **Done, 2026-11-07.** Both steps are complete: the CPU comparison (Julia 0.82 over +> native's whole runs on the M5 Max) and the Metal extension, with double-float in place +> of binary64 (`src/dfloat.jl`). The results, the floating-point experiments and an +> assessment of Julia as a first-class backend are in [STATUS.md](STATUS.md); the rows +> are in the ledger. What follows is the note as it was written. + For the agent picking this up on the maintainer's Mac (Apple M5 Max). The work is draft PR #559, branch `feature/julia-backend-experiment` (do not merge; heads `[skip ci]`). Read `AGENTS.md`, then [README.md](README.md) (setup, variables, files) and diff --git a/julia/STATUS.md b/julia/STATUS.md index e32193f43..4f911f640 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -96,18 +96,111 @@ the harness fix (#557) counted 0.18 s of metadata on both arms and are not compa - **Small states on many threads.** With one mode and 1601 bins the passes are serial by size, and run 20 to 40 % slower with 16 cores busy than with one (the clock). - **Serial plasma integrals.** The two running integrals are sequential by design. -- **Binary32 on x86.** It runs (fields 1e-6 from binary64), but slower than binary64: - the scaled field's tails are subnormal, and flush-to-zero is not allowed. GPUs handle - binary32 subnormals at full speed. +- **Binary32 on x86.** It runs (fields 1e-6 from binary64), but two to three times + slower than binary64 on the Xeon. Subnormals are not the cause: flushing them + (`SOLPROP_JULIA_FTZ=1`) left every window within its rounds' spread. Not yet found. - **The A40's binary64.** It runs at 1/64 of its binary32 rate; the A40 says little about - an H200 or an MI325X. + an H200 or an MI325X. Binary32 with the double-float wide type (below) takes it out of + the operator and the phi functions, and the windows barely move (0.99): the host is + what is left there too. +- **Metal.** The capillary windows are launch-bound (a few modes, thousands of bins); + `argon_blueshift`'s plasma takes the per-sample GPU path, and `h2_raman_6ps`'s Raman + convolution and `line` lose most to `mlx`. Not yet profiled. Construction compiles + the Metal kernels (about 28 s), with no precompiled trace for the device. + +## Apple silicon and Metal (2026-11-07) + +On the M5 Max the engine is faster than native on the CPU, and runs on its GPU. The +ledger has the rows. + +- **CPU, binary64.** 2 % windows on 1, 6 and 18 threads: 0.83 over native (16 of 21 + rows faster). Whole runs on 6 threads: 0.82 (`ctc_reduced` 0.71, `h2_raman_6ps` 0.82 + over 63 s, the Cartesian beam 1.02), the same steps, fields to 1e-11. On one thread + the two are close (0.84 to 1.23); the gap opens with threads, as native's OpenMP + regions slow on the 12 second-tier cores (eight threads already slower than six, 18 + at 1.4 to 1.5 times six's time) where Polyester's tasks lose less. +- **Accelerate.** Apple's BLAS for the products is the default on macOS: radial's + window on one thread 1.02 s -> 0.60 s, no case slower. +- **Metal.** `SolpropJuliaMetalExt` (Metal.jl 1.12), binary32 only. Every binary32 + window passes against `numpy_ref`. Against native's binary64 on six CPU threads 1.95 + (the Cartesian beam 0.33, radial 0.92, the capillaries 3 to 6); against `mlx` 1.25 + (the Cartesian beam 0.71, radial and `ctc_reduced` 0.96, `h2_raman_6ps` 2.1). + Metal.jl's FFTs (MPSGraph) cover every plan form the engine uses without MLX's + Bluestein cliff; its float32 GEMM is full precision, not TF32. +- **Double-float.** An Apple GPU has no binary64, so a binary32 run there forms the + operator's exponents, the propagators and the Adams phi functions in `DF32`, a value + as two binary32s (about 48 bits; `src/dfloat.jl`, the mlx backend's primitives), each + result rounded once to binary32. `SOLPROP_JULIA_WIDE=df32` takes it on any device; + binary64 runs keep their arithmetic exactly. Its phi functions agree with binary64's + to within 2^-36, its propagator pair to 8 binary32 ulps up to a 1e6 rad phase. +- **Measurement.** On the Mac a heavy process slows the next one's windows by 10 to + 80 % (no thermal warning): a Julia worker compiles for seconds before its window, so + the A/Bs ran both arms warm. `benchmarks ab --cooldown` idles between workers. + +## Floating point (2026-11-07) + +SEP 25 permits contraction and per-kernel reassociation and forbids umbrella fast-math, +approximations and flush-to-zero. The engine now contracts its ordinary kernels (the +stage combinations, the Adams sums, the phi series, the plasma rate's cubic, the FIR +sums); the protected helpers, the march's decisions, the defects and the norms stay as +written, and the CPU column scan's order is a choice, not policy. Contraction measured +0.99 on the M5 Max (`h2_raman_6ps` 0.93 to 0.96 the only steady gain): the engine is +bound by passes over memory, not by operations. + +Flush-to-zero, as an experiment (`SOLPROP_JULIA_FTZ=1`, #561), helped nowhere: 1.00 on +the M5 Max in binary32, 0.99 on the Xeon in binary32. It is also hazardous embedded in +Python: Julia's first thread is the interpreter's own, and a flag set there flushed +NumPy's subnormals too, failing a `math.log` in solprop's translation. The switch flushes +only inside the engine's entry points. + +## Toward a first-class backend + +What these measurements say about Julia becoming a supported backend beside, or in +place of, native and `mlx`. + +**For.** +- **Speed on a CPU.** Faster than native on the M5 Max (0.82 over whole runs), within + 13 % on the Xeon at 16 threads, faster in some rows there. +- **One source for every device.** About 3,500 lines of engine (plus the 1,600-line + compile trace and a 2,400-line adapter), against about 31,000 of native's C++. The + same scalar bodies run on CPUs, NVIDIA, AMD and now Apple GPUs; Kokkos has no Metal + backend. Intel GPUs (oneAPI.jl) should take an extension like the others. +- **A replacement for `mlx`.** Within 25 % of the hand-written `mlx` backend on its own + GPU on the first, unprofiled run, faster on the largest case. +- **Iteration.** Each device extension so far took an hour or two; the double-float + path was a day's work and runs on every device. + +**Against, or not yet.** +- **GPU speed.** About twice native on full-rate GPUs (H200 2.39, MI325X 2.48, not + re-measured since), host-bound: launches (about 75 a trial), copies and allocations. + CUDA graphs or fused trials are the next step, untried. +- **Coverage.** Julia refuses most of what native runs beyond the seven focus routes + (the list below), and several things `mlx` runs (envelope plasma, tapers, batches, + several plasma channels or Raman terms). Each is a feature to write and to test + against `numpy_ref`. +- **Distribution and start.** A Julia runtime and a 1.8 GB depot beside the wheel; + the first engine in a process compiles for 11 to 14 s on a CPU (after the + precompiled trace) and about 28 s on Metal. A PackageCompiler system image, untried, + would remove most of it. Native ships as a prebuilt wheel on PyPI. +- **Qualification.** No CI lane runs it. The double-float path has window tests and + unit bounds, not `mlx`'s SEP 33 drift and envelope qualification. +- **The toolchain's own bugs.** Julia's LinearAlgebra gave wrong concurrent + `Complex{Float32}` products (worked around); juliacall shares the interpreter's thread. + +**The decisions a SEP would take.** Whether Julia replaces native, sits beside it, or +replaces only `mlx`; which features it must cover before that; how it ships (system +image, `juliapkg`, or a separate distribution); which CI lanes run it (a CPU lane, and a +GPU lane somewhere); and whether the double-float path takes `mlx`'s qualification. +The cheapest step with the most information is to replace `mlx` first: profile Metal +on the losing cases, add `mlx`'s features, run SEP 33's qualification on `df32`, and +compare again. ## Not run Vector polarisation, batches, noise, envelope plasma, several plasma channels or Raman terms, varying Raman, dispersive Kerr, TDSE, planar and general modal guides, tapers, coupled flows, the interaction Adams formulation, the carrier frame and interpolated -planes are refused by name. +planes are refused by name; so is binary64 on Metal. ## Findings for main @@ -124,3 +217,9 @@ planes are refused by name. them as real GEMMs over the complex array's real view instead. - `docs/dev/backends.md` still names `set_held_plane` and `held_observation`, which main removed; #558. +- On the M5 Max native is slower on 8 and on 18 threads than on 6, on most cases: its + parallel regions wait for the second-tier cores. OpenMP's `active` waiting does not + change it. Not filed yet. +- On the Mac a heavy process slows the next process's windows by 10 to 80 %, so an + A/B of a compiling arm (Julia) against a quick one runs both warm; `benchmarks ab + --cooldown` (this branch) idles between workers. From be94de600530ee701298c22658e1796f23ceb01a Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 13:59:53 +0000 Subject: [PATCH 066/107] Julia: the Mac's drift corrected in the records; the cooldown A/B [skip ci] The slower native windows after the thread scan were the machine's state over the day, not a neighbouring process: native alone ran as slowly. The ratio held through every variant (0.79 with 30 s idle between workers). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 15 ++++++++------- julia/STATUS.md | 15 ++++++++------- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index dea2cb5d2..a31c39bdd 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3140,13 +3140,14 @@ The same M5 Max, later commits: `h2_raman_6ps` and `line`, and on 12 for `kerr_beam_192` and `ctc_reduced`; eight threads, two of them second-tier, are already slower than six, and 18 take 1.4 to 1.5 times six's time (`h2_raman_6ps` 0.61 -> 0.91 s). -- **The machine's state between workers.** Native's six-thread windows ran 10 to 80 % - slower right after a heavy process than in a run of native workers alone (`rdw` - 0.062 s alone, 0.083 s after Julia workers, 0.092 s after 15 s of every core busy; - `line` 0.067, 0.119 and 0.123 s), with no thermal warning recorded. A Julia worker - compiles for 7 to 30 s before its window, so every native-against-Julia A/B above - ran both arms in that state: the ratios hold, the absolute times are slow. Commit - `d872cb59` adds `benchmarks ab --cooldown`. +- **The machine's state.** Absolute times on the Mac moved by up to 40 % over the day + with no thermal warning recorded: native's six-thread `rdw` window took 0.062 s in + the thread scan and 0.083 to 0.092 s in every later run, native alone (two A/A + passes), beside Julia workers, after 15 s of every core busy, or with 30 s idle before + each worker (`benchmarks ab --cooldown`, commit `d872cb59`). A suspicion: sustained + load slows the whole machine. Interleaved arms share the state, and the ratio held + through all of it: with the cooldown 0.79 (`line` 0.62 to the Cartesian beam 0.93), + and back-to-back single-backend passes 0.72 to 0.92 by case. **NVIDIA A40** (DMOG, driver 595.71), commit `ecbcafbe`, `--device`: the device tests pass (34, binary32 in both wide types). `julia` binary32 with the double-float wide diff --git a/julia/STATUS.md b/julia/STATUS.md index 4f911f640..aa68d4b63 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -114,7 +114,7 @@ On the M5 Max the engine is faster than native on the CPU, and runs on its GPU. ledger has the rows. - **CPU, binary64.** 2 % windows on 1, 6 and 18 threads: 0.83 over native (16 of 21 - rows faster). Whole runs on 6 threads: 0.82 (`ctc_reduced` 0.71, `h2_raman_6ps` 0.82 + rows faster); on 6 threads with 30 s idle between workers 0.79. Whole runs on 6 threads: 0.82 (`ctc_reduced` 0.71, `h2_raman_6ps` 0.82 over 63 s, the Cartesian beam 1.02), the same steps, fields to 1e-11. On one thread the two are close (0.84 to 1.23); the gap opens with threads, as native's OpenMP regions slow on the 12 second-tier cores (eight threads already slower than six, 18 @@ -133,9 +133,10 @@ ledger has the rows. result rounded once to binary32. `SOLPROP_JULIA_WIDE=df32` takes it on any device; binary64 runs keep their arithmetic exactly. Its phi functions agree with binary64's to within 2^-36, its propagator pair to 8 binary32 ulps up to a 1e6 rad phase. -- **Measurement.** On the Mac a heavy process slows the next one's windows by 10 to - 80 % (no thermal warning): a Julia worker compiles for seconds before its window, so - the A/Bs ran both arms warm. `benchmarks ab --cooldown` idles between workers. +- **Measurement.** Absolute times on the Mac moved by up to 40 % over a day of + benchmarks, with no thermal warning; the ratio did not (0.79 to 0.88 over every + variant: windows, whole runs, 30 s idle between workers, single-backend passes back + to back). Quote ratios from interleaved arms, not absolute times from different runs. ## Floating point (2026-11-07) @@ -220,6 +221,6 @@ planes are refused by name; so is binary64 on Metal. - On the M5 Max native is slower on 8 and on 18 threads than on 6, on most cases: its parallel regions wait for the second-tier cores. OpenMP's `active` waiting does not change it. Not filed yet. -- On the Mac a heavy process slows the next process's windows by 10 to 80 %, so an - A/B of a compiling arm (Julia) against a quick one runs both warm; `benchmarks ab - --cooldown` (this branch) idles between workers. +- On the Mac absolute times drift by up to 40 % over a day of sustained benchmarking + (no thermal warning recorded); only interleaved ratios are comparable across runs. + `benchmarks ab --cooldown` (this branch) idles between workers; 30 s did not undo it. From 19215f031642dfb8c51c7d488a566681b28c53a3 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 14:19:51 +0000 Subject: [PATCH 067/107] Julia: a GPU's strided product operands copied into scratch first [skip ci] Metal.jl takes a generic kernel for a product whose operand is a range of a matrix's rows (about 240 us for 16384 x 36 x 8 on the M5 Max, against 65 to 140 us copied first). On a GPU, gemm! now copies such an operand into the engine's scratch. Metal A/B, two rounds: h2_raman_6ps 0.76 (1.92 -> 1.45 s), radial 0.91, the rest within their rounds, the same steps; the Metal binary32 windows pass. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 6 ++++++ julia/src/launch.jl | 12 ++++++++++++ 2 files changed, 18 insertions(+) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index a31c39bdd..9e3940e98 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3174,3 +3174,9 @@ spread on one thread and on 16 (radial 0.89 on 16 the largest move). The binary3 windows here take 2 to 3 times binary64's (`rdw` on one thread 1.43 s, 0.63 s in binary64 at `a6722029`), and flushing subnormals does not change that: they are not the cause. +- **Metal, strided products copied first** (commit after `be94de60`, two rounds, + `--device`, pow2): on a GPU `gemm!` copies an operand that is a row range of a matrix + into scratch before the product, since Metal.jl takes a generic kernel for one (about + 240 us for 16384 x 36 x 8 against 65 to 140 us copied). `h2_raman_6ps` 1.92 -> 1.45 s + (0.76; its Raman nodal products and projections), radial 0.91, the rest within their + rounds; the same steps. Against `mlx`'s 0.92 s, `h2_raman_6ps` is about 1.6, not 2.1. diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 886bfaffb..0f4437b12 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -308,6 +308,9 @@ function gemm!(C, A, B, alpha, beta, c) if eltype(C) <: Complex && eltype(A) <: Complex && eltype(B) <: Real return gemm!(real_rows(C), real_rows(A), B, alpha, beta, c) end + if !oncpu(c) + A, B = dense(c, A, :gemm_a), dense(c, B, :gemm_b) + end if oncpu(c) && eltype(C) <: Real && (size(B, 2) <= THIN || size(B, 1) <= THIN) return thin_gemm!(C, A, B, alpha, beta, c) end @@ -321,6 +324,15 @@ function gemm!(C, A, B, alpha, beta, c) C end +"""On a GPU, an operand that is a strided view (a range of a matrix's rows) copied into +scratch: Metal.jl's product of one takes a generic kernel, about 240 us for 16384 x 36 +x 8 on the M5 Max against 65 to 140 us copied first.""" +function dense(c, X::SubArray{<:Any,2}, use) + strides(X) == (1, size(X, 1)) && return X + copyto!(scratch(c, use, eltype(X), size(X)...), X) +end +dense(c, X, use) = X + """A product's thin side, at most this many columns or inner terms: a loop, not BLAS.""" const THIN = 8 From b60663f096182e011541d84fe80702c479ed066e Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 14:20:32 +0000 Subject: [PATCH 068/107] Julia: Metal's wait costs in STATUS [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/STATUS.md | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/julia/STATUS.md b/julia/STATUS.md index aa68d4b63..4d4a08456 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -103,10 +103,17 @@ the harness fix (#557) counted 0.18 s of metadata on both arms and are not compa an H200 or an MI325X. Binary32 with the double-float wide type (below) takes it out of the operator and the phi functions, and the windows barely move (0.99): the host is what is left there too. -- **Metal.** The capillary windows are launch-bound (a few modes, thousands of bins); - `argon_blueshift`'s plasma takes the per-sample GPU path, and `h2_raman_6ps`'s Raman - convolution and `line` lose most to `mlx`. Not yet profiled. Construction compiles - the Metal kernels (about 28 s), with no precompiled trace for the device. +- **Metal.** The capillary windows are bound by waits on the device. On the M5 Max a + queued kernel launch costs 4.8 us, but each value the host waits for costs about + 0.2 ms: a launch and `synchronize` 160 us, a reduction read back 210 us, a 40 kB copy + to the host 190 us (CUDA's are tens of microseconds). The trial's norms, the + quadrature alarm, the monitor and the statistics each wait; fewer of them a step (the + sums fused and read once, or kept on the device until the march needs them) is the + next lever. The section timers put `commit` (its alarm's transforms and reduction) + at about 1.2 ms a step on `rdw` and `argon_blueshift`. `h2_raman_6ps`'s strided + products are fixed (0.76); its Raman products and projections are still its largest + share. Construction compiles the Metal kernels (about 28 s), with no precompiled + trace for the device. ## Apple silicon and Metal (2026-11-07) From 4614c717926961a9fd53907715aebfacede7a94a Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 14:28:35 +0000 Subject: [PATCH 069/107] Julia: the manual page, README and STATUS brought up to date for the next worker [skip ci] The manual page's numbers and devices predated the rewrite; it now lists the AMD and Apple GPUs, the double-float wide type and the current geometric means. README: the harness's --device-arm, --cooldown and per-arm wrapper scripts, and the Metal test command. STATUS: next steps in order, with the working setups on the Mac, DMOG and the Xeon. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/guide/performance/julia.md | 34 +++++++++++++++++++++------------ julia/README.md | 10 +++++++++- julia/STATUS.md | 28 +++++++++++++++++++++++++++ 3 files changed, 59 insertions(+), 13 deletions(-) diff --git a/docs/guide/performance/julia.md b/docs/guide/performance/julia.md index 389349258..1be3b1db5 100644 --- a/docs/guide/performance/julia.md +++ b/docs/guide/performance/julia.md @@ -1,8 +1,8 @@ # The Julia experiment `backend="julia"` is an experiment on this branch, not a supported backend: it asks how -fast one compact Julia source can run solprop's routes on a CPU and on an NVIDIA GPU, -in binary64 or binary32. Use the [native backend](native.md) for results. The design, +fast one compact Julia source can run solprop's routes on a CPU and on NVIDIA, AMD and +Apple GPUs, in binary64 or binary32. Use the [native backend](native.md) for results. The design, the measurements and what is left are in the branch's `julia/STATUS.md`. ## What it runs @@ -16,7 +16,7 @@ refuses by name what it does not run. | routes | resolved and mode-averaged capillaries (constant radius, separable longitudinal profiles), radial, Cartesian and line free space | planar and general modal guides, tapers, coupled flows | | responses | Kerr (with THG), one field-grid plasma channel, one constant Raman term (modal) | envelope plasma, several channels or Raman terms, varying Raman, dispersive Kerr, TDSE, noise | | steppers | DOPRI5 with FSAL, the exponential Adams march (not Cartesian), RK4IP (Cartesian) | the interaction Adams formulation, the carrier frame, interpolated planes | -| execution | CPU threads; an NVIDIA GPU (`SOLPROP_JULIA_DEVICE=cuda`); `precision="double"` or `"single"` | vector polarisation, batches | +| execution | CPU threads; an NVIDIA GPU (`SOLPROP_JULIA_DEVICE=cuda`), an AMD GPU (`rocm`) or an Apple GPU (`metal`, binary32 only); `precision="double"` or `"single"` | vector polarisation, batches; binary64 on an Apple GPU | ## Trying it @@ -24,7 +24,7 @@ From a checkout of the branch: ```sh uv sync --extra julia -uv run --no-sync python julia/bootstrap.py # add --cuda for a GPU +uv run --no-sync python julia/bootstrap.py # add --cuda, --rocm or --metal for a GPU SOLPROP_JULIA_THREADS=16 uv run --no-sync python my_run.py # with backend="julia" ``` @@ -45,15 +45,25 @@ made a run slower on four threads than on one. The plasma's columns use branch-f vectorised `exp` and `log` within one ulp, and the exponential Adams march itself runs in the engine, as native's compiled march does. In binary32 the state is held as `a / s` for SEP 33's power-of-two scale `s`, and the operator stays binary64, so -propagators and the longitudinal root are formed in binary64 and rounded once. +propagators and the longitudinal root are formed in binary64 and rounded once. Where the +device has no binary64 (an Apple GPU), or on request (`SOLPROP_JULIA_WIDE=df32`), they +are formed in double-float instead, a value as two binary32s (about 48 bits), and still +rounded once. On macOS the products use Apple's Accelerate. ## How fast it is -Indicative only: short windows of the benchmark cases, measured with `python -m -benchmarks ab` against native on the same machine. The branch's ledger +Indicative only: the seven focus cases, measured with `python -m benchmarks ab` +against native on the same machine, as julia's time over native's (below one, julia is +faster). The branch's ledger ([benchmarks](../../dev/benchmarks.md#julia-backend-experiment)) has the numbers, the -machines and the commits. On a 16-core Xeon the julia backend takes 1.0 to 2.1 times -native's time (geometric mean 1.4), at parity on the `rdw` and `ctc_reduced` capillary -windows; on an NVIDIA A40 in binary64, 1.3 to 3.9 times native's CUDA build. What is -left is mostly the GPU's transforms and launches, and on a CPU the radial and -Cartesian routes' many threads. +machines and the commits. + +| machine | geometric mean | notes | +|---|---:|---| +| Apple M5 Max CPU, 6 threads | 0.82 | whole runs; 0.68 to 1.02 by case | +| Intel Xeon Gold 6240, 16 threads | 1.13 | 2 % windows; 0.78 to 1.26 | +| NVIDIA A40, binary64 | 1.97 | host-bound | +| NVIDIA H200 / AMD MI325X, binary64 | 2.39 / 2.48 | host-bound; before later fixes | +| Apple M5 Max GPU, binary32 | 1.95 against native's 6 CPU threads; 1.25 against `mlx` | the Cartesian beam 0.33 and 0.71 | + +On GPUs what is left is the host: the launches, copies and waits of each step. diff --git a/julia/README.md b/julia/README.md index accf7c5f9..2b8ca42f1 100644 --- a/julia/README.md +++ b/julia/README.md @@ -69,6 +69,13 @@ uv run --no-sync python -m benchmarks ab --baseline-backend native --candidate-b --baseline-python .venv/bin/python --case rdw --threads 1,16 --length 0.02 --noise none ``` +`--device` runs both arms on the GPU that `SOLPROP_JULIA_DEVICE` names; `--device-arm +candidate` runs only that arm there, against a CPU arm. `--cooldown 30` idles before each +worker. On the Mac absolute times drift by up to 40 % over a day, so compare only +interleaved arms. An arm can take its own environment through a wrapper script given as +`--candidate-python` (for example one that sets `SOLPROP_JULIA_WIDE=df32`, or +`SOLPROP_JULIA_ROOT` to another tree's sources). + `python julia/profile.py PLAN.json ROW...` times one plan row's complete run, warmed, with `SOLPROP_JULIA_TIMING=1` for the sections or `SOLPROP_JULIA_PROFILE=1` for Julia's sampling profile. `julia/bench/launch.jl` is the launch-strategy measurement the device @@ -77,7 +84,8 @@ layer rests on. ## Testing ```sh -uv run --no-sync pytest tests/backends/test_julia.py -n 4 # SOLPROP_JULIA_DEVICE=cuda on a GPU +uv run --no-sync pytest tests/backends/test_julia.py -n 4 # CPU +SOLPROP_JULIA_DEVICE=metal uv run --no-sync pytest tests/backends/test_julia.py -m gpu # or cuda, rocm ``` Seven focus windows against `numpy_ref`: the same steps, and the field to `1e-10` in diff --git a/julia/STATUS.md b/julia/STATUS.md index 4d4a08456..02dddaed8 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -203,6 +203,34 @@ The cheapest step with the most information is to replace `mlx` first: profile M on the losing cases, add `mlx`'s features, run SEP 33's qualification on `df32`, and compare again. +## Next steps + +Measured or diagnosed, not yet done, roughly in order of what they would tell. + +1. **Metal's waits.** Fuse the per-step reductions the host reads (the trial's norms, + the quadrature alarm, the monitor) into fewer readbacks, about 0.2 ms each on the + M5 Max. Profile with `SOLPROP_JULIA_TIMING=1 SOLPROP_JULIA_DEVICE=metal python + julia/profile.py PLAN.json ROW` (a plan's rows need `"backend": "native"` to be + picked). +2. **`mlx`'s coverage on Metal.** Envelope plasma, tapers, batches, several plasma + channels and Raman terms; then SEP 33's drift and envelope qualification of the + double-float path. With 1, enough to decide whether Julia can replace `mlx`. +3. **Metal start latency.** Record the device's specialisations into a trace as + `src/precompile_trace.jl` was, or try a PackageCompiler system image. +4. **Binary32 on x86.** Two to three times binary64 on the Xeon, and not subnormals. + Profile one thread, `rdw`, binary32 against binary64 section by section. +5. **The GPU host on CUDA and ROCm.** CUDA graphs or fused trials (launches about 75 a + trial); re-measure an H200 or MI325X afterwards, not before. +6. **Native.** #333 (default budget on Apple silicon: the top-tier cores) and #560's + ideas, which these measurements feed. + +The working setups: on the Mac a worktree with native built on the NEON FFTW prefix +(`~/buildtools/fftw-3.3.11-neon`) and `uv sync --extra julia --extra mlx`; on DMOG +`/mnt/data/shared/jt52/solprop-julia-20261106` (`jl13-a40.sbatch` reuses a native CUDA +wheel and runs the tests and two A/Bs); on the Xeon +`~/awork/solprop-julia-ftz-20261107` (a venv without native, for Julia-only A/Bs). +The raw data are in the private `solprop-dev/benchmarks/julia-m5-2026-11-07`. + ## Not run Vector polarisation, batches, noise, envelope plasma, several plasma channels or Raman From da5559f04f121690329ffb8d3ffacc39f930ae89 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 15:44:31 +0000 Subject: [PATCH 070/107] Julia: launch and wait counters; a GPU's constant projection rows kept contiguous [skip ci] SOLPROP_JULIA_COUNT=1 counts a device's kernel launches, the values the host waits for, uploads, products, strided copies, scans and scratch allocations; julia/profile.py prints them a step. On a GPU, table_rows keeps a contiguous copy of each chunk's rows of the constant projection tables, made once, where each product copied them (ctc_reduced on Metal: 36 copies a step -> 5). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/profile.py | 6 ++++++ julia/src/SolpropJulia.jl | 2 ++ julia/src/adams.jl | 1 + julia/src/helpers.jl | 1 + julia/src/launch.jl | 29 +++++++++++++++++++++++++++-- julia/src/modal.jl | 8 ++++---- julia/src/responses.jl | 5 +++-- julia/src/stages.jl | 1 + 8 files changed, 45 insertions(+), 8 deletions(-) diff --git a/julia/profile.py b/julia/profile.py index 5de266977..0e0f22e87 100644 --- a/julia/profile.py +++ b/julia/profile.py @@ -46,6 +46,7 @@ def profile(row: dict) -> None: Main.seval("using Profile; Profile.init(n=10^7, delay=0.0005)") Main.seval("Profile.clear(); Profile.start_timer()") jl.clear_timings() + jl.clear_counts() record, _ = timed_run( simulation, problem, engine, retention, simulation._boundary_monitor() ) @@ -63,6 +64,11 @@ def profile(row: dict) -> None: ) for name in sorted(times, key=lambda n: -float(times[n])): sys.stdout.write(f" {name:>18} {float(times[name]):8.4f} s\n") + # SOLPROP_JULIA_COUNT=1: the device's launches, waits and allocations a step. + counts = {str(k): int(v) for k, v in jl.counts().items()} + steps = max(int(record["accepted"]), 1) + for name in sorted(counts): + sys.stdout.write(f" {name:>18} {counts[name] / steps:8.1f} a step ({counts[name]})\n") engine.close() diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 943271bf1..3d57bef16 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -53,6 +53,7 @@ real_type(engine) = real(eltype(engine.work.y)) # Read at load, not at precompilation: a constant would be baked into the cache. function __init__() TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "1" + COUNT[] = get(ENV, "SOLPROP_JULIA_COUNT", "0") == "1" CHECK[] = get(ENV, "SOLPROP_JULIA_CHECK", "0") == "1" SAMPLE_PLASMA[] = get(ENV, "SOLPROP_JULIA_PLASMA", "columns") == "samples" nothing @@ -188,6 +189,7 @@ function reset_work!(engine) foreach(buffer -> fill!(buffer, 0), buffers) engine.fsal_valid, engine.calls, engine.propagator_dz = false, 0, NaN TIMING[] && empty!(TIMES) + COUNT[] && empty!(COUNTS) nothing end diff --git a/julia/src/adams.jl b/julia/src/adams.jl index 0b5f23de6..451d8bf75 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -141,6 +141,7 @@ function configure_adams!(engine, predictor, corrector, defects, slots, spans, c h.cdefects[1:count, 1:width] .= Matrix{Float64}(cdefects) h.rate .= Vector{Float64}(rate) end + oncpu(engine.config) || tally!(:upload, length(a.device)) foreach(copyto!, a.device, a.host) nothing end diff --git a/julia/src/helpers.jl b/julia/src/helpers.jl index 43d56bd55..7c95b5c8c 100644 --- a/julia/src/helpers.jl +++ b/julia/src/helpers.jl @@ -168,6 +168,7 @@ function configure_adams_nodes!(engine, nodes, order, orders, slots, rate) h.ccorrector[1:order+1] .= corrector h.rate .= Vector{Float64}(rate) end + oncpu(engine.config) || tally!(:upload, length(a.device)) foreach(copyto!, a.device, a.host) nothing end diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 0f4437b12..7e597b4bb 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -19,10 +19,19 @@ oncpu(c) = c.backend isa KA.CPU """Put a host array on the engine's device, owning it on the CPU too.""" upload(::KA.CPU, a::Array) = a -upload(backend, a::Array) = copyto!(KA.allocate(backend, eltype(a), size(a)), a) +upload(backend, a::Array) = (tally!(:upload); copyto!(KA.allocate(backend, eltype(a), size(a)), a)) upload(c::NamedTuple, a::Array) = upload(c.backend, a) dzeros(c, T, dims...) = KA.zeros(c.backend, T, dims...) +# Development counters (SOLPROP_JULIA_COUNT=1 when the module loads): a device's kernel +# launches, the values the host waits for, uploads, products and scratch allocations, +# by kind. Off, `tally!` costs one branch. +const COUNT = Ref(false) +const COUNTS = Dict{Symbol,Int}() +@inline tally!(kind::Symbol, n=1) = (COUNT[] && (COUNTS[kind] = get(COUNTS, kind, 0) + n); nothing) +counts() = Dict(String(k) => v for (k, v) in COUNTS) +clear_counts() = (empty!(COUNTS); nothing) + # Below this many samples one pass is faster on one thread than split over tasks # (julia/bench/launch.jl: a Kerr pass over 10240 x 4 takes 8.5 us on one thread of the # Xeon, 10.5 us on four). @@ -93,6 +102,7 @@ KA.@kernel inbounds = true function each_kernel!(f) f(t, m) end function each_on!(f::F, backend, tasks, nt, nm, heavy) where {F} + tally!(:launch) each_kernel!(backend, (256, 1))(f; ndrange=(nt, nm)) nothing end @@ -100,7 +110,7 @@ end """A device scratch array the engine keeps (`c.scratch`), by its use, type and shape: a GPU's pool allocations a trial were dozens.""" scratch(c, use::Symbol, T, dims...) = - get!(() -> KA.allocate(c.backend, T, dims...), c.scratch, (use, T, dims)) + get!(() -> (tally!(:scratch_alloc); KA.allocate(c.backend, T, dims...)), c.scratch, (use, T, dims)) """`f(t, m)` at every sample, into a device scratch matrix of `out`'s element type, for a device reduction over its rows or columns.""" @@ -120,6 +130,7 @@ function each_column!(f::F, c, nm::Integer) where {F} @inline f(m) end else + tally!(:launch) AK.foreachindex(f, 1:Int(nm); backend=c.backend, block_size=64) end nothing @@ -147,6 +158,7 @@ function rowsum!(f::F, c, out, nt::Integer, nm::Integer) where {F} # terms fill a scratch matrix in parallel and the device's reduction sums it. scratch = reduce_terms(f, c, out, nt, nm) total = SolpropJulia.scratch(c, :rows, eltype(out), nt, 1) + tally!(:launch, 2) sum!(total, scratch) out .+= vec(total) end @@ -175,6 +187,7 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=fa end return foldl(op, partials; init=neutral) end + tally!(:readback) if heavy # A heavy body a thread: AK's reduction gives each thread several elements # (six blocks for rdw's 10244, its predictor 539 us a trial on an A40), so the @@ -309,6 +322,7 @@ function gemm!(C, A, B, alpha, beta, c) return gemm!(real_rows(C), real_rows(A), B, alpha, beta, c) end if !oncpu(c) + tally!(:gemm) A, B = dense(c, A, :gemm_a), dense(c, B, :gemm_b) end if oncpu(c) && eltype(C) <: Real && (size(B, 2) <= THIN || size(B, 1) <= THIN) @@ -329,10 +343,21 @@ scratch: Metal.jl's product of one takes a generic kernel, about 240 us for 1638 x 8 on the M5 Max against 65 to 140 us copied first.""" function dense(c, X::SubArray{<:Any,2}, use) strides(X) == (1, size(X, 1)) && return X + tally!(:dense_copy) copyto!(scratch(c, use, eltype(X), size(X)...), X) end dense(c, X, use) = X +"""Rows `first:last` of a constant table (a projection), for a product: a view on a CPU; +on a GPU a contiguous copy, made once and kept in `c.scratch`, since a product with a +strided operand there takes a generic kernel or a copy every call (`dense`).""" +function table_rows(c, table, first, last) + oncpu(c) && return @view(table[first:last, :]) + first == 1 && last == size(table, 1) && return table + get!(() -> (tally!(:scratch_alloc); copy(@view(table[first:last, :]))), + c.scratch, (:table_rows, objectid(table), first, last)) +end + """A product's thin side, at most this many columns or inner terms: a loop, not BLAS.""" const THIN = 8 diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 1c19f4a59..e2daa7d04 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -132,9 +132,9 @@ function source!(engine, lab; quadrature=false) end products && @section :raman raman_nodal!(w.raman, first, last, c) node_response!(engine, count) - @section :projection gemm!(w.projected, nodes, @view(c.projection[first:last, :]), true, true, c) + @section :projection gemm!(w.projected, nodes, table_rows(c, c.projection, first, last), true, true, c) quadrature && c.embedded && - gemm!(w.projected_coarse, nodes, @view(c.projection_coarse[first:last, :]), true, true, c) + gemm!(w.projected_coarse, nodes, table_rows(c, c.projection_coarse, first, last), true, true, c) end end if w.plasma === nothing @@ -257,9 +257,9 @@ function source_spectral!(engine, lab, quadrature) @section :forward_fft mul!(node_fine, w.node_forward, nodes) @section :plasma_spectrum spectral_plasma!(node_band, node_fine, w.plasma, w.node_forward, c) @section :projection begin - gemm!(band_source, band, @view(c.projection[first:last, :]), true, true, c) + gemm!(band_source, band, table_rows(c, c.projection, first, last), true, true, c) quadrature && c.embedded && - gemm!(band_coarse, band, @view(c.projection_coarse[first:last, :]), true, true, c) + gemm!(band_coarse, band, table_rows(c, c.projection_coarse, first, last), true, true, c) end end loss = nothing diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 96f8f647f..e4eb08932 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -337,6 +337,7 @@ function integrate_samples!(out, values, taps, dt, c, count) @inbounds out[t, n] = t == 1 ? none : half * (filtered(values, t, n, taps) + filtered(values, t - 1, n, taps)) end + tally!(:scan) AK.accumulate!(+, @view(out[:, 1:count]); dims=1, init=zero(dt), backend=c.backend) nothing end @@ -409,9 +410,9 @@ function project_plasma!(p, c, first, last, quadrature) count = last - first + 1 for (values, full, coarse) in ((p.gated, p.projected, p.coarse), (p.edge, p.edge_projected, p.coarse_edge)) block = @view values[:, 1:count] - gemm!(full, block, @view(c.projection[first:last, :]), true, true, c) + gemm!(full, block, table_rows(c, c.projection, first, last), true, true, c) quadrature && c.embedded && - gemm!(coarse, block, @view(c.projection_coarse[first:last, :]), true, true, c) + gemm!(coarse, block, table_rows(c, c.projection_coarse, first, last), true, true, c) end end diff --git a/julia/src/stages.jl b/julia/src/stages.jl index fedc93a67..77f2ede0d 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -24,6 +24,7 @@ function configure_stages!(engine, delta, weights, material) copyto!(p.delta, Matrix{Float64}(delta)) copyto!(p.weights, Matrix{Float64}(weights)) copyto!(p.material, Matrix{Float64}(material)) + oncpu(engine.config) || tally!(:upload, 2) copyto!(p.delta_device, widen_host(wide_eltype(engine.config), p.delta)) copyto!(p.weights_device, real_type(engine).(p.weights)) material_stage!(engine, 1) From 37aed946becef8e5301b6af2a8d080c3569c8021 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 16:10:21 +0000 Subject: [PATCH 071/107] Julia: device copies as one kernel, views included [skip ci] Metal.jl's copyto! into or out of a view took about 200 us: transform_all!'s staged FFT batch (three copies in, one batched transform, three out) took 1.6 ms for three 8192 x 4 transforms that take 0.11 ms separately, and pool_copy!'s history copies into the Adams store and dense's strided copies took the same path. device_copy! is the pool's elementwise copy on every device. Also: the upload counters no longer read engine.config (the helper tests pass a stand-in). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/adams.jl | 2 +- julia/src/dopri.jl | 2 +- julia/src/helpers.jl | 2 +- julia/src/launch.jl | 16 ++++++++++------ julia/src/modal.jl | 2 +- julia/src/stages.jl | 2 +- 6 files changed, 15 insertions(+), 11 deletions(-) diff --git a/julia/src/adams.jl b/julia/src/adams.jl index 451d8bf75..bf579d327 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -141,7 +141,7 @@ function configure_adams!(engine, predictor, corrector, defects, slots, spans, c h.cdefects[1:count, 1:width] .= Matrix{Float64}(cdefects) h.rate .= Vector{Float64}(rate) end - oncpu(engine.config) || tally!(:upload, length(a.device)) + a.device.predictor isa Array || tally!(:upload, length(a.device)) foreach(copyto!, a.device, a.host) nothing end diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 9f1c8a60b..efe253223 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -176,7 +176,7 @@ function quadrature_alarm(engine) else p = w.plasma transform_all!(w.forward_plan, (w.coarse_spec, p.spectrum, p.edge_spectrum), - (w.projected_coarse, p.coarse, p.coarse_edge), w.forward_stage) + (w.projected_coarse, p.coarse, p.coarse_edge), w.forward_stage, c) add_plasma_spectra!(w.coarse_spec, p, c) end (; prefactor, omega_window, crop) = c diff --git a/julia/src/helpers.jl b/julia/src/helpers.jl index 7c95b5c8c..b13acb126 100644 --- a/julia/src/helpers.jl +++ b/julia/src/helpers.jl @@ -168,7 +168,7 @@ function configure_adams_nodes!(engine, nodes, order, orders, slots, rate) h.ccorrector[1:order+1] .= corrector h.rate .= Vector{Float64}(rate) end - oncpu(engine.config) || tally!(:upload, length(a.device)) + a.device.predictor isa Array || tally!(:upload, length(a.device)) foreach(copyto!, a.device, a.host) nothing end diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 7e597b4bb..a1235a170 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -267,7 +267,7 @@ end # four for rdw, 96 us each on an A40): the group goes through one batched plan over a # staging buffer instead, the copies a few microseconds each. The staging lives in the # engine's workspace (`stage`, a `Ref`), not in a global table of plans. -function transform_all!(p, outs::Tuple, ins::Tuple, stage::Ref) +function transform_all!(p, outs::Tuple, ins::Tuple, stage::Ref, c) x = first(ins) if x isa Array foreach((y, x) -> mul!(y, p, x), outs, ins) @@ -283,15 +283,15 @@ function transform_all!(p, outs::Tuple, ins::Tuple, stage::Ref) end staged, result, batched = held for j in 1:n - copyto!(view(staged, :, (j-1)*columns+1:j*columns), ins[j]) + device_copy!(view(staged, :, (j-1)*columns+1:j*columns), ins[j], c) end mul!(result, batched, staged) for j in 1:n - copyto!(outs[j], view(result, :, (j-1)*columns+1:j*columns)) + device_copy!(outs[j], view(result, :, (j-1)*columns+1:j*columns), c) end nothing end -transform_all!(p::Blocked, outs::Tuple, ins::Tuple, ::Ref) = transform_all!(p, outs, ins) +transform_all!(p::Blocked, outs::Tuple, ins::Tuple, ::Ref, c) = transform_all!(p, outs, ins) function Base.:*(p::Blocked, x) @batch for b in eachindex(p.plans) @@ -303,13 +303,17 @@ end """`copyto!(target, source)` for two state-sized arrays of the device: on a CPU as the pool's tasks, since one thread's copy of a Cartesian state (226 MB) took 45 ms.""" function pool_copy!(target, source, c) - oncpu(c) || return copyto!(target, source) each!(c, size(target)...) do f, m @inbounds target[f, m] = source[f, m] end target end +"""`copyto!(target, source)` for two matrices of the device, views included, as one +kernel: Metal.jl's `copyto!` into or out of a view took about 200 us (a staged FFT batch +of three 8192 x 4 transforms 1.6 ms against 0.11 ms for three separate ones).""" +device_copy!(target, source, c) = pool_copy!(target, source, c) + """`C = alpha A B + beta C`: on a CPU, blocks of rows of `C` and `A` as the pool's tasks. A complex `C` and `A` against a real `B` are their real views, of twice the rows: one @@ -344,7 +348,7 @@ x 8 on the M5 Max against 65 to 140 us copied first.""" function dense(c, X::SubArray{<:Any,2}, use) strides(X) == (1, size(X, 1)) && return X tally!(:dense_copy) - copyto!(scratch(c, use, eltype(X), size(X)...), X) + device_copy!(scratch(c, use, eltype(X), size(X)...), X, c) end dense(c, X, use) = X diff --git a/julia/src/modal.jl b/julia/src/modal.jl index e2daa7d04..80ece8193 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -144,7 +144,7 @@ function source!(engine, lab; quadrature=false) p = w.plasma @section :forward_fft transform_all!(w.forward_plan, (w.fine, p.spectrum, p.edge_spectrum), (w.projected, p.projected, p.edge_projected), - w.forward_stage) + w.forward_stage, c) @section :plasma_spectrum add_plasma_spectra!(w.fine, p, c) end if c.in_stage diff --git a/julia/src/stages.jl b/julia/src/stages.jl index 77f2ede0d..5c72696a0 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -24,7 +24,7 @@ function configure_stages!(engine, delta, weights, material) copyto!(p.delta, Matrix{Float64}(delta)) copyto!(p.weights, Matrix{Float64}(weights)) copyto!(p.material, Matrix{Float64}(material)) - oncpu(engine.config) || tally!(:upload, 2) + p.delta_device isa Array || tally!(:upload, 2) copyto!(p.delta_device, widen_host(wide_eltype(engine.config), p.delta)) copyto!(p.weights_device, real_type(engine).(p.weights)) material_stage!(engine, 1) From 5df088ecac4cdc7d9fd683f9a2bbd0f1f010d5c9 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 16:39:59 +0000 Subject: [PATCH 072/107] Julia: one value the host waits for a GPU step [skip ci] On a GPU the Adams predictor's squared norm stays on the device for the corrector to read (sum_device!), and the quadrature or band alarm's two sums join the corrector's norms (or DOPRI's combine sums) in one reduction; the commit takes the cached alarm instead of transforming and reducing again. On Metal (0.2 ms a wait) rdw and h2_raman_6ps go from three readbacks a step to one. A CPU keeps its paths and bits: the norms are formed by the same operations, and the alarm's sums alone are regrouped (its consumers are the warning and a statistic compared to a factor of two). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/SolpropJulia.jl | 5 +++ julia/src/adams.jl | 43 +++++++++++++++---- julia/src/dopri.jl | 87 ++++++++++++++++++++++++--------------- julia/src/free.jl | 2 +- julia/src/launch.jl | 18 ++++++++ julia/src/modal.jl | 2 +- 6 files changed, 114 insertions(+), 43 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 3d57bef16..25bc5023e 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -32,6 +32,10 @@ mutable struct Engine{C,W} calls::Int propagator_dz::Float64 factor::Float64 + # A GPU trial's quadrature alarm, read back with its norms (`alarm_arrays`) and + # handed to the commit that follows, so that the commit waits for nothing. + alarm::Float64 + alarm_ready::Bool end include("launch.jl") @@ -188,6 +192,7 @@ function reset_work!(engine) a === nothing || (buffers = (buffers..., a.store, a.states, a.rates, a.moments, a.carried, a.endpoint)) foreach(buffer -> fill!(buffer, 0), buffers) engine.fsal_valid, engine.calls, engine.propagator_dz = false, 0, NaN + engine.alarm, engine.alarm_ready = NaN, false TIMING[] && empty!(TIMES) COUNT[] && empty!(COUNTS) nothing diff --git a/julia/src/adams.jl b/julia/src/adams.jl index bf579d327..fc239e3e3 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -201,7 +201,10 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} # The predictor, the flow and its moments, and the state's norm for the scale. active = c.mask none, nil, h = zero(T), zero(C), T(step) - squared = @section :adams_predict reduce_each(+, zero(T), c, size(y)...; heavy=true) do f, m + # The state's squared norm, for the corrector's scale, stays where the corrector + # reads it: on a GPU the device (`sum_device!`). + squared = scratch(c, :adams_squared, T, 1) + @section :adams_predict sum_device!(squared, c, size(y)...; heavy=true) do f, m @inbounds begin # Outside the band the state, the history and the source are exactly zero, # and so is everything this element forms. @@ -250,14 +253,37 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} end w.path === nothing || material_stage!(engine, 7) source!(engine, lab; quadrature=true) - magnitude = sqrt(squared) - relative, absolute, weight = T(c.rtol) * magnitude, T(c.atol), c.weights - zero3 = (zero(T), zero(T), zero(T)) - norms = @section :adams_correct reduce_each(.+, zero3, c, size(y)...; heavy=true) do f, m + # A GPU reads the quadrature alarm with the norms, for the commit to take. + alarm = oncpu(c) ? nothing : alarm_arrays(engine) + norms = @section :adams_correct corrector_norms(engine, Val(N), squared, h, alarm) + alarm === nothing || hold_alarm!(engine, norms) + [sqrt(Float64(norms[row])) for row in 1:count] +end + +"""The corrected candidate and the defect norms' squares, one to three, and with an +`alarm` (`alarm_arrays`) its two sums after them, in one reduction: one value the host +waits for a trial.""" +function corrector_norms(engine, ::Val{N}, squared, h, alarm) where {N} + c, w = engine.config, engine.work + a = w.adams + order, _, count = a.sizes + T = real_type(engine) + C = Complex{T} + (; y, forward, candidate, source) = w + (; store, moments, carried, endpoint) = a + (; corrector, defects, ccorrector, cdefects, slots) = a.device + compensated = a.compensated + active, mask, weight = c.mask, c.norm_mask, c.weights + rtol, absolute = T(c.rtol), T(c.atol) + none, nil = zero(T), zero(C) + zero3 = (none, none, none) + neutral = alarm === nothing ? zero3 : (zero3..., none, none) + reduce_each(.+, neutral, c, size(y)...; heavy=true) do f, m @inbounds begin + extra = alarm === nothing ? () : alarm_term(alarm, f, m) if !active[f] candidate[f, m] = 0 - return zero3 + return (zero3..., extra...) end corrected = nil for k in 1:N @@ -277,6 +303,8 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} candidate[f, m] = muladd(h, corrected, forward[f, m, 1] * y[f, m]) result = zero3 if mask[f] + # rtol |y|, formed as the host formed it from the predictor's sum. + relative = rtol * sqrt(squared[1]) scale = relative * weight[f] + absolute for row in 1:count difference = defects[row, 1] * source[f, m] @@ -300,10 +328,9 @@ function adams_trial_width!(engine, h, ::Val{N}) where {N} result = Base.setindex(result, score, row) end end - result + (result..., extra...) end end - [sqrt(Float64(norms[row])) for row in 1:count] end function adams_accept!(engine, slot) diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index efe253223..a5da4069b 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -78,9 +78,24 @@ function combine!(engine, dz, slot) mask = c.norm_mask b = ntuple(s -> T(dz * c.b[s]), Val(7)) e = ntuple(s -> T(dz * c.e[s]), Val(7)) + # A GPU reads the quadrature alarm with the norms, for the commit to take. + alarm = oncpu(c) ? nothing : alarm_arrays(engine) + sums = combine_sums(y, candidate, error, stages, forward, mask, b, e, slot, alarm, c, T) + alarm === nothing || hold_alarm!(engine, sums) + magnitude = max(sqrt(sums[1]), sqrt(sums[2])) + if c.uniform + scale = T(c.rtol) * magnitude + T(c.atol) + return scale == 0 ? (sums[3] == 0 ? 0.0 : Inf) : Float64(sqrt(sums[3]) / scale) + end + weighted_norm(engine, error, magnitude) +end + +function combine_sums(y, candidate, error, stages, forward, mask, b, e, slot, alarm, c, T) zero3 = (zero(T), zero(T), zero(T)) - sums = reduce_each(.+, zero3, c, size(y)...) do f, m + neutral = alarm === nothing ? zero3 : (zero3..., zero(T), zero(T)) + reduce_each(.+, neutral, c, size(y)...) do f, m @inbounds begin + extra = alarm === nothing ? () : alarm_term(alarm, f, m) solution, defect = zero(eltype(y)), zero(eltype(y)) for s in 1:7 value = stages[f, m, s] @@ -92,15 +107,9 @@ function combine!(engine, dz, slot) estimate = flow * defect candidate[f, m] = new error[f, m] = estimate - mask[f] ? (abs2(y[f, m]), abs2(new), abs2(estimate)) : zero3 + ((mask[f] ? (abs2(y[f, m]), abs2(new), abs2(estimate)) : zero3)..., extra...) end end - magnitude = max(sqrt(sums[1]), sqrt(sums[2])) - if c.uniform - scale = T(c.rtol) * magnitude + T(c.atol) - return scale == 0 ? (sums[3] == 0 ? 0.0 : Inf) : Float64(sqrt(sums[3]) / scale) - end - weighted_norm(engine, error, magnitude) end function weighted_norm(engine, error, magnitude) @@ -167,10 +176,13 @@ function collar_factor(rate, half, inverse, c) factor end -"""The embedded coarse quadrature's relative defect in the last stage's source.""" -function quadrature_alarm(engine) +"""The quadrature alarm's arrays for a reduction body (`alarm_term`), its transforms done: +the exact and the coarse spectra, the crop (`nothing` on the band), the prefactor and +the window; `nothing` without an embedded quadrature.""" +function alarm_arrays(engine) c, w = engine.config, engine.work - c.spectral && return band_alarm(engine) + c.embedded || return nothing + c.spectral && return (w.band_source, w.band_coarse, nothing, c.prefactor, c.omega_window) if w.plasma === nothing mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) else @@ -179,30 +191,39 @@ function quadrature_alarm(engine) (w.projected_coarse, p.coarse, p.coarse_edge), w.forward_stage, c) add_plasma_spectra!(w.coarse_spec, p, c) end - (; prefactor, omega_window, crop) = c - fine, coarse = w.fine, w.coarse_spec - T = real_type(engine) - sums = reduce_each(.+, (zero(T), zero(T)), c, size(w.y)...) do f, m - @inbounds begin - weight = prefactor[f, m] * omega_window[f] - exact = weight * fine[crop[f], m] - (abs2(exact), abs2(weight * coarse[crop[f], m] - exact)) - end + (w.fine, w.coarse_spec, c.crop, c.prefactor, c.omega_window) +end + +"""One element's two alarm sums: the exact source's power and its coarse error's.""" +@inline function alarm_term(alarm, f, m) + exact, coarse, crop, prefactor, window = alarm + @inbounds begin + k = crop === nothing ? f : crop[f] + weight = prefactor[f, m] * window[f] + value = weight * exact[k, m] + (abs2(value), abs2(weight * coarse[k, m] - value)) end - sums[1] == 0 ? NaN : Float64(sqrt(sums[2] / sums[1])) end +alarm_value(power, error) = power == 0 ? NaN : Float64(sqrt(error / power)) -function band_alarm(engine) - c, w = engine.config, engine.work - (; prefactor, omega_window) = c - exact, coarse = w.band_source, w.band_coarse - T = real_type(engine) - sums = reduce_each(.+, (zero(T), zero(T)), c, size(w.y)...) do f, m - @inbounds begin - weight = prefactor[f, m] * omega_window[f] - value = weight * exact[f, m] - (abs2(value), abs2(weight * coarse[f, m] - value)) - end +"""The relative error of the quadrature's coarse source against the exact one: the +GPU trial's own, read with its norms, when it left one (`alarm_ready`).""" +function quadrature_alarm(engine) + if engine.alarm_ready + engine.alarm_ready = false + return engine.alarm end - sums[1] == 0 ? NaN : Float64(sqrt(sums[2] / sums[1])) + alarm = alarm_arrays(engine) + T = real_type(engine) + sums = alarm_sums(alarm, engine.config, T, size(engine.work.y)) + alarm_value(sums...) +end +alarm_sums(alarm, c, T, dims) = + reduce_each((f, m) -> alarm_term(alarm, f, m), .+, (zero(T), zero(T)), c, dims...) +band_alarm(engine) = quadrature_alarm(engine) + +"""Keep a GPU trial's alarm, read with its norms, for the commit.""" +function hold_alarm!(engine, sums) + engine.alarm = alarm_value(sums[end-1], sums[end]) + engine.alarm_ready = true end diff --git a/julia/src/free.jl b/julia/src/free.jl index 39eac4ea5..d905c85ed 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -69,7 +69,7 @@ function create_free(c, host) coarse_inverse=c.envelope ? plan(c, plan_bfft, coarse_spec, 1) : plan(c, plan_brfft, coarse_spec, nc, 1), coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), ) - Engine(c, work, false, 0, NaN, c.factor) + Engine(c, work, false, 0, NaN, c.factor, NaN, false) end # For an exactly real squared longitudinal wave number the principal root is sqrt(x) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index a1235a170..629897496 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -205,6 +205,24 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=fa end end +"""The sum of `f(t, m)` over every sample into `out[1]`, which the next kernel reads: on a +GPU it stays on the device (each value the host waits for cost about 0.2 ms on an M5 +Max), on a CPU it is `reduce_each`'s, the same bits.""" +function sum_device!(f::F, out, c, nt::Integer, nm::Integer; heavy=false) where {F} + nt, nm = Int(nt), Int(nm) + if oncpu(c) + @inbounds out[1] = reduce_each(f, +, zero(eltype(out)), c, nt, nm; heavy=heavy) + return out + end + terms = SolpropJulia.scratch(c, :sum_terms, eltype(out), 1, nt * nm) + each!(c, nt, nm) do t, m + @inbounds terms[1, t+(m-1)*nt] = f(t, m) + end + tally!(:launch) + sum!(reshape(out, 1, 1), terms) + out +end + # FFTW's planner measures every plan unless SOLPROP_FFTW_PLAN says otherwise. Unlike # native's policy (rows estimated when threaded), a threaded estimate is far slower # here: the Raman convolution's c2r of 73728 x 17 takes 6.6 ms estimated and 1.49 ms diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 80ece8193..28f47de45 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -92,7 +92,7 @@ function create_modal(c, host) coarse_inverse=c.envelope ? plan(c, plan_bfft, band, 1) : plan(c, plan_brfft, band, c.nc, 1), coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), ) - Engine(c, work, false, 0, NaN, c.factor) + Engine(c, work, false, 0, NaN, c.factor, NaN, false) end """Place a band-limited state in the fine spectrum, clearing the padding.""" From a38097f823438eddd034f56dfd5f357658d39a12 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 17:32:56 +0000 Subject: [PATCH 073/107] Julia: one chunk of nodes a source on a GPU [skip ci] The translation sizes a source's node chunk for a CPU's memory budget (ctc_reduced's 33 nodes three chunks of 11, h2_raman_6ps's two of 17, radial's two of 192), and each chunk repeats the synthesis, the responses and the projections. On a GPU the engine takes every node at once, up to 2^26 samples a buffer: on Metal ctc_reduced's products a step 42 -> 8.5 and launches 66 -> 35, h2_raman_6ps's products 16 -> 4. A CPU keeps the translation's chunk. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/free.jl | 2 +- julia/src/launch.jl | 7 +++++++ julia/src/modal.jl | 2 +- 3 files changed, 9 insertions(+), 2 deletions(-) diff --git a/julia/src/free.jl b/julia/src/free.jl index d905c85ed..32292e41f 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -42,7 +42,7 @@ function create_free(c, host) temporal_rate=upload(c, T.(c.split ? zero(c.rate) : c.rate)), in_stage=in_stage, coarse_rate=upload(c, T.(c.coarse_rate)), nc=nc, embedded=false, )) - chunk = min(host.int("chunk"), nm) + chunk = node_chunk(c, host.int("chunk"), nm, nt) R = c.envelope ? C : T stages = c.low_storage ? 0 : 7 physical = dzeros(c, C, nw, nm) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 629897496..3c0e5d6c5 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -370,6 +370,13 @@ function dense(c, X::SubArray{<:Any,2}, use) end dense(c, X, use) = X +"""The nodes (or columns) a source evaluates at once: the translation's chunk, sized for a +CPU's memory budget, on a CPU; on a GPU all of them, up to 2^26 samples a buffer, since +each chunk repeats the synthesis, the responses and the projections as launches +(`ctc_reduced`'s 33 nodes were three chunks of 11).""" +node_chunk(c, chunk, count, nt) = + oncpu(c) ? min(chunk, count) : min(count, max(chunk, (1 << 26) ÷ max(nt, 1))) + """Rows `first:last` of a constant table (a projection), for a product: a view on a CPU; on a GPU a contiguous copy, made once and kept in `c.scratch`, since a product with a strided operand there takes a generic kernel or a copy every call (`dense`).""" diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 28f47de45..449991d45 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -37,7 +37,7 @@ function create_modal(c, host) in_stage = any(!iszero, spatial) || (!c.split && any(!iszero, c.rate)) nw, nm = size(host.array("linear", ComplexF64)) nn = size(synthesis, 2) - chunk = min(host.int("chunk"), nn) + chunk = node_chunk(c, host.int("chunk"), nn, nt) R = c.envelope ? C : T # Synthesis and projection in the frequency domain, on the band's rows (`source_spectral!`), # where the nodes are about as many as the modes, as radially: half the GEMM rows of From fbd75c2c278d0305f3fc42c963ab578812a974d9 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 17:54:46 +0000 Subject: [PATCH 074/107] Julia: a GPU trial's tables in one upload [skip ci] On a GPU the Adams trial's real tables are views of one device vector, refreshed by one copy a trial, with the integer slots beside it: two uploads a trial where there were nine to eleven (each an interleaved copy, about 14 us on Metal). A CPU keeps an array a table. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/adams.jl | 50 ++++++++++++++++++++++++++++++++++++++++---- julia/src/helpers.jl | 3 +-- 2 files changed, 47 insertions(+), 6 deletions(-) diff --git a/julia/src/adams.jl b/julia/src/adams.jl index fc239e3e3..4f93d4573 100644 --- a/julia/src/adams.jl +++ b/julia/src/adams.jl @@ -112,15 +112,58 @@ function adams_workspace(c, host, nw, nm) defects=zeros(3, 2width), spans=zeros(width), cpredictor=zeros(width), ccorrector=zeros(width + 1), cdefects=zeros(3, width), rate=zeros(nphi), slots=zeros(Int, slots)) + tables_on_device = device_tables(c, tables) (store=dzeros(c, C, nw, nm, slots), states=held(nw, nm, slots), rates=held(nw, nm, slots), moments=dzeros(c, C, nw, nm, width), carried=held(nw, nm, max(width - 1, 0)), # The device's tables at the state's precision: a binary64 coefficient beside a # binary32 state would widen a trial's every product (and its norms' types). endpoint=held(nw, nm), host=tables, - device=map(a -> upload(c.backend, eltype(a) <: Integer ? copy(a) : c.T.(a)), tables), + device=tables_on_device.device, packed=tables_on_device.packed, sizes=zeros(Int, 3), compensated=compensated) end +"""The device's copies of the trial's tables: on a CPU an array each; on a GPU the real +tables views of one device vector (`packed`), refreshed by one copy a trial with the +integer slots beside it (`upload_tables!`), where nine small uploads a trial were nine +round trips through the copy engine.""" +function device_tables(c, tables) + if oncpu(c) + device = map(a -> upload(c.backend, eltype(a) <: Integer ? copy(a) : c.T.(a)), tables) + return (device=device, packed=nothing) + end + reals = Base.structdiff(tables, NamedTuple{(:slots,)}) + total = sum(length, values(reals)) + packed = dzeros(c, c.T, total) + stops = cumsum(collect(map(length, values(reals)))) + views = ntuple(k -> reshape(view(packed, stops[k]-length(reals[k])+1:stops[k]), size(reals[k])), + length(reals)) + device = merge(NamedTuple{keys(reals)}(views), (slots=upload(c.backend, copy(tables.slots)),)) + (device=device, packed=(device=packed, host=zeros(c.T, total))) +end + +"""Copy the host's trial tables to the device: each on a CPU, one packed copy and the +slots on a GPU.""" +function upload_tables!(a) + packed = hasproperty(a, :packed) ? a.packed : nothing + if packed === nothing + foreach(copyto!, a.device, a.host) + return nothing + end + staging, offset = packed.host, 0 + for name in keys(a.host) + name === :slots && continue + table = getproperty(a.host, name) + for k in eachindex(table) + @inbounds staging[offset+k] = table[k] + end + offset += length(table) + end + tally!(:upload, 2) + copyto!(packed.device, staging) + copyto!(a.device.slots, a.host.slots) + nothing +end + function configure_adams!(engine, predictor, corrector, defects, slots, spans, cpredictor, ccorrector, cdefects, rate) a = engine.work.adams @@ -141,14 +184,13 @@ function configure_adams!(engine, predictor, corrector, defects, slots, spans, c h.cdefects[1:count, 1:width] .= Matrix{Float64}(cdefects) h.rate .= Vector{Float64}(rate) end - a.device.predictor isa Array || tally!(:upload, length(a.device)) - foreach(copyto!, a.device, a.host) + upload_tables!(a) nothing end function configure_adams_rate!(engine, rate) a = engine.work.adams a.host.rate .= Vector{Float64}(rate) - copyto!(a.device.rate, a.host.rate) + upload_tables!(a) nothing end diff --git a/julia/src/helpers.jl b/julia/src/helpers.jl index b13acb126..7acc8f23b 100644 --- a/julia/src/helpers.jl +++ b/julia/src/helpers.jl @@ -168,8 +168,7 @@ function configure_adams_nodes!(engine, nodes, order, orders, slots, rate) h.ccorrector[1:order+1] .= corrector h.rate .= Vector{Float64}(rate) end - a.device.predictor isa Array || tally!(:upload, length(a.device)) - foreach(copyto!, a.device, a.host) + upload_tables!(a) nothing end From 7669f5d420026524961824c1fd0443d46711fb38 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 18:40:46 +0000 Subject: [PATCH 075/107] Julia: the Metal tuning rows and the A40 rows at 5df088ec [skip ci] Julia on the M5 Max GPU against mlx: 0.67 (1.25 this morning), faster in six of seven cases. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 9e3940e98..66c24836c 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3180,3 +3180,39 @@ the cause. 240 us for 16384 x 36 x 8 against 65 to 140 us copied). `h2_raman_6ps` 1.92 -> 1.45 s (0.76; its Raman nodal products and projections), radial 0.91, the rest within their rounds; the same steps. Against `mlx`'s 0.92 s, `h2_raman_6ps` is about 1.6, not 2.1. + +**Metal tuning, 2026-11-07 evening** (M5 Max GPU, `julia32` with df32, `--device`, 4 host +threads, 2 % windows; each change against its parent, three rounds unless said). The +counters (`SOLPROP_JULIA_COUNT=1`) and probes found the costs: a `copyto!` into or out of +a view took about 200 us on Metal (a staged FFT batch 1.6 ms against 0.11 ms for three +transforms), each switch between the engine's kernels and MPS/MPSGraph work about 30 us, +each value the host waits for about 0.2 ms. + +| change | commit | geometric mean | largest effects | +|---|---|---:|---| +| a chunk's constant projection rows kept contiguous | `da5559f0` | 0.93 (two rounds) | `ctc_reduced` 0.74, `argon_blueshift` 0.84 | +| device copies as one kernel, views included | `37aed946` | 0.81 | `rdw` 0.61, `argon_blueshift` 0.71, `ctc_reduced` 0.75 | +| one value the host waits for a step | `5df088ec` | about 0.95 | `h2_raman_6ps` 0.80, `argon_blueshift` 0.82, `rdw` 0.88 (a loaded machine; reruns) | +| one chunk of nodes a source on a GPU | `a38097f8` | 0.84 | `ctc_reduced` 0.61, `h2_raman_6ps` 0.72, radial 0.88 | +| the trial's tables in one upload | `fbd75c2c` | 0.99 | within the rounds | + +Against `mlx` at `fbd75c2c` (binary32, `MLX_ENABLE_TF32=0`, pow2, three rounds; this +morning 1.25): + +| case | `mlx`, s | julia Metal, s | ratio | +|---|---:|---:|---:| +| `rdw` | 0.405 | 0.166 | 0.41 | +| `argon_blueshift` | 0.389 | 0.281 | 0.73 | +| `h2_raman_6ps` | 0.896 | 0.682 | 0.76 | +| `ctc_reduced` | 0.926 | 0.238 | 0.26 | +| `radial_filament_256` | 0.203 | 0.185 | 0.91 | +| `kerr_beam_192` | 0.249 | 0.191 | 0.77 | +| `line` | 0.132 | 0.199 | 1.49 | + +Geometric mean 0.67: Julia faster than `mlx` in six of seven cases, fields 4e-7 to 2e-5 +apart (binary32 against binary32). + +**NVIDIA A40** at `5df088ec` (the first three changes): against `ecbcafbe` 0.97 in +binary64 (the view copies were Metal's problem); against native, binary64 1.88 (1.97 +before; `h2_raman_6ps` 1.00, `ctc_reduced` 1.44, `kerr_beam_192` 2.97) and binary32 with +df32 1.51 (1.72 before; `h2_raman_6ps` 0.58, radial 1.29). From 0686c8bfce0947c14c052f21b4ca2c1d296ddb11 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 18:45:42 +0000 Subject: [PATCH 076/107] Julia: a GPU's population statistics in one readback a chunk [skip ci] The per-sample population path read back seven reductions and made two copies into views a chunk (about 0.2 ms each on Metal). One column kernel now writes each column's final fraction and peak into the device's tables and its six partial maxima into a small matrix, read back once. The binary64 windows pass against numpy_ref through this path on a CPU (SOLPROP_JULIA_PLASMA=samples), statistics included. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/responses.jl | 38 +++++++++++++++++++++++++++++--------- 1 file changed, 29 insertions(+), 9 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index e4eb08932..e09924086 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -472,15 +472,35 @@ function population_samples!(p, nodes, c, first, count) each!(c, nt, count) do t, n @inbounds edge[t, n] = t == 1 ? none : dt * (gated[t, n] + gated[t-1, n]) / 2 end - steps = @view integrand[:, columns] - final, start = @view(fraction[nt, columns]), @view(fraction[1, columns]) - copyto!(@view(fractions[first:first+count-1]), final) - copyto!(@view(peaks[first:first+count-1]), vec(maximum(@view(rate[:, columns]); dims=1))) - freed = Array(final) .- Array(start) - paid = vec(Array(sum(@view(edge[:, columns]); dims=1))) - Float64[max(0, maximum(-, steps)), max(0, maximum(steps)), maximum(abs.(paid .- freed)), - maximum(freed), maximum(@view(current[1:min(reach, nt), columns])), - maximum(@view(current[:, columns]))] + # One column kernel writes each column's final fraction and peak rate into the + # device's tables and its six partial maxima into a small matrix, read back once: the + # separate reductions and view copies were seven waits and two slow copies a chunk + # (each about 0.2 ms on Metal). + parts = scratch(c, :population_parts, T, 6, count) + head = min(reach, nt) + each_column!(c, count) do n + @inbounds begin + down, up, peak, early, latest, paid = none, none, none, none, none, none + for t in 1:nt + step = integrand[t, n] + down, up = max(down, -step), max(up, step) + peak = max(peak, rate[t, n]) + paid += edge[t, n] + value = current[t, n] + latest = max(latest, value) + t <= head && (early = max(early, value)) + end + freed = fraction[nt, n] - fraction[1, n] + fractions[first+n-1] = fraction[nt, n] + peaks[first+n-1] = peak + parts[1, n], parts[2, n], parts[3, n] = down, up, abs(paid - freed) + parts[4, n], parts[5, n], parts[6, n] = freed, early, latest + end + end + host = Array(parts) + tally!(:readback) + Float64[max(0, maximum(host[1, :])), max(0, maximum(host[2, :])), maximum(host[3, :]), + maximum(host[4, :]), maximum(host[5, :]), maximum(host[6, :])] end function population_columns!(p, nodes, c, first, count) From 9af3cd508e4458cd538f143445738801f878e89f Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 19:02:05 +0000 Subject: [PATCH 077/107] Julia: the population statistics' reductions parallel, not a thread a column [skip ci] A thread a column looping down it (the previous commit) was slower than the seven readbacks it replaced: a capillary has a few columns of thousands of samples. The columns' sums and peaks are now device reductions, each column's final values a small kernel, and the six maxima one reduction over every sample, read back once. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/responses.jl | 50 ++++++++++++++++++++++-------------------- 1 file changed, 26 insertions(+), 24 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index e09924086..434cc341e 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -472,36 +472,38 @@ function population_samples!(p, nodes, c, first, count) each!(c, nt, count) do t, n @inbounds edge[t, n] = t == 1 ? none : dt * (gated[t, n] + gated[t-1, n]) / 2 end - # One column kernel writes each column's final fraction and peak rate into the - # device's tables and its six partial maxima into a small matrix, read back once: the - # separate reductions and view copies were seven waits and two slow copies a chunk - # (each about 0.2 ms on Metal). - parts = scratch(c, :population_parts, T, 6, count) - head = min(reach, nt) - each_column!(c, count) do n + # The columns' work sums and peak rates as device reductions, each column's final + # fraction, peak and defect by a small kernel, and the six maxima as one reduction + # over every sample, read back once: the separate reductions and view copies were + # seven waits and two slow copies a chunk (each about 0.2 ms on Metal). A thread a + # column, looping down it, was slower still: a capillary has a few columns. + paid = scratch(c, :population_paid, T, 1, count) + peak = scratch(c, :population_peak, T, 1, count) + sum!(paid, @view(edge[:, columns])) + maximum!(peak, @view(rate[:, columns])) + tally!(:launch, 2) + defects = scratch(c, :population_defects, T, 2, count) + each!(c, count, 1) do n, _ @inbounds begin - down, up, peak, early, latest, paid = none, none, none, none, none, none - for t in 1:nt - step = integrand[t, n] - down, up = max(down, -step), max(up, step) - peak = max(peak, rate[t, n]) - paid += edge[t, n] - value = current[t, n] - latest = max(latest, value) - t <= head && (early = max(early, value)) - end freed = fraction[nt, n] - fraction[1, n] fractions[first+n-1] = fraction[nt, n] - peaks[first+n-1] = peak - parts[1, n], parts[2, n], parts[3, n] = down, up, abs(paid - freed) - parts[4, n], parts[5, n], parts[6, n] = freed, early, latest + peaks[first+n-1] = peak[1, n] + defects[1, n], defects[2, n] = abs(paid[1, n] - freed), freed + end + end + head, lowest = min(reach, nt), typemin(T) + maxima = reduce_each(tuple_max, (none, none, none, lowest, none, none), c, nt, count) do t, n + @inbounds begin + step, value = integrand[t, n], current[t, n] + first_row = t == 1 + (-step, step, first_row ? defects[1, n] : none, first_row ? defects[2, n] : lowest, + t <= head ? value : none, value) end end - host = Array(parts) - tally!(:readback) - Float64[max(0, maximum(host[1, :])), max(0, maximum(host[2, :])), maximum(host[3, :]), - maximum(host[4, :]), maximum(host[5, :]), maximum(host[6, :])] + Float64[max(0, maxima[1]), max(0, maxima[2]), maxima[3], maxima[4], maxima[5], maxima[6]] end +"""The elementwise maximum of two tuples, for `reduce_each`.""" +tuple_max(a, b) = map(max, a, b) function population_columns!(p, nodes, c, first, count) T = typeof(p.dt) From 0d84bb740116be97e9976e604be3451f409a530f Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 19:16:35 +0000 Subject: [PATCH 078/107] Julia: the A40's Nsight profiles in the ledger [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 66c24836c..300b08199 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3216,3 +3216,20 @@ apart (binary32 against binary32). binary64 (the view copies were Metal's problem); against native, binary64 1.88 (1.97 before; `h2_raman_6ps` 1.00, `ctc_reduced` 1.44, `kerr_beam_192` 2.97) and binary32 with df32 1.51 (1.72 before; `h2_raman_6ps` 0.58, radial 1.29). + +**NVIDIA A40, Nsight Systems** at `fbd75c2c` (binary64, one warmed 2 % window inside +`cudaProfilerStart`/`Stop`, `scripts/prof_case.py` on DMOG): one-chunk and the packed +tables against `5df088ec` gave 0.95 (`h2_raman_6ps` 0.90, `ctc_reduced` 0.91). The +profiles show that on the A40 in binary64 Julia is bound by device work, not the host: + +| case | native kernels | julia kernels | FFTs a step, native / julia | windows, native / julia | +|---|---|---|---|---| +| `rdw` | 15 ms, 592 launches | 80 ms, 2975 launches | 1.7 / 5.4 | 0.054 / 0.130 s | +| `h2_raman_6ps` | 117 ms | 868 ms | 0.38 / 14.4 | 1.05 / 1.09 s | +| `radial_filament_256` | 65 ms | 209 ms | | 0.17 / 0.29 s | + +Native's `h2_raman_6ps` window is host-bound instead (984 ms of API time for 117 ms of +kernels), which is why the two windows are level there. Julia's elementwise kernels take +50 ms of `rdw`'s 80 (one heavy kernel a step, the Adams predictor's phi functions in +binary64 at the A40's 1/64 rate, 0.28 ms), its FFTs 19 ms; radial's FP64 GEMMs (cutlass) +58 ms. The gap is native's lighter algorithm per source, not Julia's launches. From 8d76f04ee81c38afadd79725abf462988eee8110 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 19:24:20 +0000 Subject: [PATCH 079/107] Julia: the A40 profile's caveat (native's sources run in CUDA graphs) [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 300b08199..b9ea52cec 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3219,17 +3219,13 @@ df32 1.51 (1.72 before; `h2_raman_6ps` 0.58, radial 1.29). **NVIDIA A40, Nsight Systems** at `fbd75c2c` (binary64, one warmed 2 % window inside `cudaProfilerStart`/`Stop`, `scripts/prof_case.py` on DMOG): one-chunk and the packed -tables against `5df088ec` gave 0.95 (`h2_raman_6ps` 0.90, `ctc_reduced` 0.91). The -profiles show that on the A40 in binary64 Julia is bound by device work, not the host: - -| case | native kernels | julia kernels | FFTs a step, native / julia | windows, native / julia | -|---|---|---|---|---| -| `rdw` | 15 ms, 592 launches | 80 ms, 2975 launches | 1.7 / 5.4 | 0.054 / 0.130 s | -| `h2_raman_6ps` | 117 ms | 868 ms | 0.38 / 14.4 | 1.05 / 1.09 s | -| `radial_filament_256` | 65 ms | 209 ms | | 0.17 / 0.29 s | - -Native's `h2_raman_6ps` window is host-bound instead (984 ms of API time for 117 ms of -kernels), which is why the two windows are level there. Julia's elementwise kernels take -50 ms of `rdw`'s 80 (one heavy kernel a step, the Adams predictor's phi functions in -binary64 at the A40's 1/64 rate, 0.28 ms), its FFTs 19 ms; radial's FP64 GEMMs (cutlass) -58 ms. The gap is native's lighter algorithm per source, not Julia's launches. +tables against `5df088ec` gave 0.95 (`h2_raman_6ps` 0.90, `ctc_reduced` 0.91). A first +profile counted native's kernels at a fraction of Julia's (`rdw` 15 ms against 80, +`h2_raman_6ps` 117 against 868), but native runs each Adams source inside a CUDA graph +(`graph::Region`, `native/src/general.cpp:8219`), which Nsight traces as one unit by +default: those counts left out native's sources and are not comparable. A rerun traces +the graph's nodes (`--cuda-graph-trace=node`). What the code shows directly is that +native's sources do fewer transforms: the analytic signal by one c2c inverse of the +doubled one-sided spectrum (Julia: a c2r, then an fft/bfft pair), the forward streams +packed into one r2c, radial's three streams in one r2c with stacked projections; +`h2_raman_6ps`'s Raman is an FFT convolution of 2 n_t on both. From aa5d654427e4265b5aaff9474aeeb4218d21ca8d Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 19:30:09 +0000 Subject: [PATCH 080/107] Julia: the analytic signal from the spectrum, as native forms it [skip ci] Where the field grid needs an analytic signal (Kerr through it, or Raman other than its third harmonic) on the time-domain modal path, the modes' doubled one-sided spectrum goes through one complex inverse transform, the nodes' analytic signal comes from the (real) synthesis of it, and the field is its real part. It replaces the real inverse over the modes and a forward and inverse pair over the nodes a source (rdw: five transforms a step -> three; h2_raman_6ps's products take the modes' analytic signals directly). The real inverse stays where the real modes are read: the in-stage absorber and a third-harmonic Raman's products. An odd grid keeps the old path. Every test passes: the binary64 windows within 1e-10 of numpy_ref on its steps. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/modal.jl | 60 +++++++++++++++++++++++++++++++++++++----- julia/src/responses.jl | 9 ++++--- 2 files changed, 60 insertions(+), 9 deletions(-) diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 449991d45..4e9b57fd1 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -46,9 +46,17 @@ function create_modal(c, host) # Raman or an unsplit temporal collar, which read the modes' time signals. spectral = !c.envelope && !host.flag("raman") && 2nm >= nn && !(!c.split && any(!iszero, c.rate)) + # The analytic signal from the spectrum, as native forms it: the modes' doubled + # one-sided spectrum and one complex inverse transform, the nodes' analytic signal + # by the (real) synthesis, its real part the field. It replaces a real inverse and + # a forward and inverse pair over the nodes a source, and matches them to rounding + # (the synthesis commutes with the projection onto positive frequencies). An odd + # grid keeps the time-domain pair, whose middle-bin rule differs. + from_spectrum = !c.envelope && !spectral && iseven(nt) && + (c.analytic || (host.flag("raman") && !host.flag("raman_thg"))) # Every inverse transform is unnormalised: its 1/nt is folded into the tables that # read the time-domain field, the synthesis and the in-stage absorber. - c = merge(c, (spectral=spectral, spectral_absorber=upload(c, T.(spatial)), + c = merge(c, (spectral=spectral, from_spectrum=from_spectrum, spectral_absorber=upload(c, T.(spatial)), # The operator stays binary64 at either precision, or a double-float where the # device lacks binary64: propagators and the Adams flow are formed from it in # that wide type and rounded once (SEP 33, 4.1 item 3). @@ -64,6 +72,7 @@ function create_modal(c, host) modal = dzeros(c, R, nt, nm) nodes = dzeros(c, R, nt, chunk) analytic = dzeros(c, C, nt, chunk) + analytic_modes = dzeros(c, C, from_spectrum ? nt : 0, from_spectrum ? nm : 0) coarse = dzeros(c, R, c.nc, nm) band = dzeros(c, C, nw, nm) # The spectral path's buffers: a chunk's node spectra on the band and the fine grid, @@ -82,7 +91,8 @@ function create_modal(c, host) y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), stages=dzeros(c, C, nw, nm, ns), forward=dzeros(c, C, nw, nm, ns), inverse=dzeros(c, C, nw, nm, ns), - fine=fine, modal=modal, nodes=nodes, analytic=analytic, + fine=fine, modal=modal, nodes=nodes, analytic=analytic, analytic_modes=analytic_modes, + analytic_modes_inverse=from_spectrum ? plan(c, plan_bfft!, analytic_modes, 1) : nothing, projected=dzeros(c, R, nt, spectral ? 0 : nm), projected_coarse=dzeros(c, R, nt, spectral ? 0 : nm), coarse_spec=similar(fine), absorber=dzeros(c, R, nt, spectral ? 0 : nm), absorber_spec=similar(fine), coarse=coarse, @@ -95,6 +105,24 @@ function create_modal(c, host) Engine(c, work, false, 0, NaN, c.factor, NaN, false) end +"""The modes' analytic signals from their half spectrum `fine`: the one-sided spectrum +doubled (the zero and Nyquist bins once, their real parts as the real inverse reads +them), the negative frequencies zero, and one unnormalised complex inverse in place: +`nt` times each mode's analytic signal, as the real inverse gives `nt` times its field.""" +function analytic_modes!(analytic, fine, inverse, c) + nt = size(analytic, 1) + half, nf, none = nt ÷ 2, size(fine, 1), zero(eltype(analytic)) + each!(c, size(analytic)...) do k, m + @inbounds begin + value = k <= nf ? fine[k, m] : none + analytic[k, m] = k == 1 || k == half + 1 ? complex(real(value)) : + k <= half ? 2 * value : none + end + end + inverse * analytic + nothing +end + """Place a band-limited state in the fine spectrum, clearing the padding.""" function scatter!(fine, lab, c) uncrop = c.uncrop @@ -113,19 +141,37 @@ function source!(engine, lab; quadrature=false) c.spectral && return source_spectral!(engine, lab, quadrature) nm = size(lab, 2) @section :scatter scatter!(w.fine, lab, c) - @section :inverse_fft mul!(w.modal, w.inverse_plan, w.fine) + raman = w.raman + # The real modes where something reads them: the time-domain analytic signal, the + # in-stage absorber, a third-harmonic Raman's products. + real_modes = !c.from_spectrum || c.in_stage || + (raman !== nothing && raman.products && raman.thg) + real_modes && @section :inverse_fft mul!(w.modal, w.inverse_plan, w.fine) + c.from_spectrum && @section :inverse_fft analytic_modes!(w.analytic_modes, w.fine, + w.analytic_modes_inverse, c) fill!(w.projected, 0) quadrature && fill!(w.projected_coarse, 0) clear_plasma!(w.plasma) if engine.factor != 0 || w.plasma !== nothing || w.raman !== nothing products = w.raman !== nothing && w.raman.products - products && @section :raman raman_products!(w.raman, w.modal, c) + products && @section :raman raman_products!(w.raman, w.modal, c; + signal=c.from_spectrum ? w.analytic_modes : nothing) chunk, nn = size(w.nodes, 2), size(c.synthesis, 2) for first in 1:chunk:nn last = min(first + chunk - 1, nn) count = last - first + 1 nodes = @view w.nodes[:, 1:count] - @section :synthesis gemm!(nodes, w.modal, @view(c.synthesis[:, first:last]), true, false, c) + if c.from_spectrum + # The nodes' analytic signal by the synthesis, the field its real part. + analytic = @view w.analytic[:, 1:count] + @section :synthesis gemm!(analytic, w.analytic_modes, @view(c.synthesis[:, first:last]), + true, false, c) + each!(c, size(analytic)...) do t, m + @inbounds nodes[t, m] = real(analytic[t, m]) + end + else + @section :synthesis gemm!(nodes, w.modal, @view(c.synthesis[:, first:last]), true, false, c) + end if w.plasma !== nothing @section :plasma plasma_current!(w.plasma, w.nodes, c, count) @section :plasma_projection project_plasma!(w.plasma, c, first, last, quadrature) @@ -165,7 +211,9 @@ function node_response!(engine, count) raman === nothing || raman_drive!(raman, nodes, nodes, c, count) nonlinear_envelope!(nodes, c, engine.factor, raman, count) elseif c.analytic || (raman !== nothing && !raman.thg && !raman.products) - @section :analytic analytic_signal!(w.analytic, nodes, w.analytic_forward, w.analytic_inverse, c, count) + # Formed from the spectrum already (`source!`), or here from the nodes. + c.from_spectrum || + @section :analytic analytic_signal!(w.analytic, nodes, w.analytic_forward, w.analytic_inverse, c, count) raman === nothing || raman.products || @section :raman raman_drive!(raman, nodes, w.analytic, c, count) @section :kerr nonlinear_nodes!(nodes, c.analytic ? w.analytic : nodes, c, engine.factor, raman, count) else diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 434cc341e..b46f05c09 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -621,7 +621,7 @@ function raman_drive!(r, nodes, analytic, c, count) end """Convolve the modal products once a source: `a_m a_n`, or `Re(a_m conj a_n) / 2`.""" -function raman_products!(r, modal, c) +function raman_products!(r, modal, c; signal=nothing) nt, modes = size(modal) (; drive, first, second) = r if r.thg @@ -629,8 +629,11 @@ function raman_products!(r, modal, c) @inbounds drive[t, p] = t > nt ? zero(eltype(drive)) : modal[t, first[p]] * modal[t, second[p]] end else - signal = r.signal - analytic_signal!(signal, modal, r.signal_forward, r.signal_inverse, c, modes) + # The modes' analytic signals: given (formed from the spectrum), or from `modal`. + if signal === nothing + signal = r.signal + analytic_signal!(signal, modal, r.signal_forward, r.signal_inverse, c, modes) + end each!(c, 2nt, size(drive, 2)) do t, p @inbounds begin a, b = signal[t, first[p]], signal[t, second[p]] From 0f2c184285856d09a52dd05f99d0b757a510bbf9 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 19:50:03 +0000 Subject: [PATCH 081/107] Julia: a GPU source's forward streams packed into one transform [skip ci] On a GPU the time-domain modal source's forward streams are column blocks of one buffer, as native packs them: the projected source, the plasma's two currents, then their coarse quadratures. One r2c takes a source's streams (with the quadrature, all six) and assembles the coarse spectrum for the alarm, where the source's batch and the alarm's each went through staging copies (twelve copies and a transform a step). A CPU keeps its blocked plans. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/dopri.jl | 2 ++ julia/src/modal.jl | 48 ++++++++++++++++++++++++++++++++++++++---- julia/src/responses.jl | 7 ++++-- 3 files changed, 51 insertions(+), 6 deletions(-) diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index a5da4069b..8bdea00e8 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -183,6 +183,8 @@ function alarm_arrays(engine) c, w = engine.config, engine.work c.embedded || return nothing c.spectral && return (w.band_source, w.band_coarse, nothing, c.prefactor, c.omega_window) + # A GPU's packed streams: the quadrature source transformed and assembled them. + w.pack === nothing || return (w.fine, w.coarse_spec, c.crop, c.prefactor, c.omega_window) if w.plasma === nothing mul!(w.coarse_spec, w.forward_plan, w.projected_coarse) else diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 4e9b57fd1..20a302f4a 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -79,6 +79,35 @@ function create_modal(c, host) # its polarisation's, and the band's projected source (and its coarse quadrature's). node_band = dzeros(c, C, spectral ? nw : 0, spectral ? chunk : 0) node_fine = dzeros(c, C, spectral ? nf : 0, spectral ? chunk : 0) + # On a GPU the forward streams are column blocks of one buffer, as native packs them: + # the projected source, the plasma's two currents, then their coarse quadratures. + # One transform takes a source's streams (with the quadrature, all six), where the + # streams' batches went through staging copies, the quadrature's a second time. + plasma = plasma_workspace(c, host, nt, chunk, nm, nn) + pack = nothing + if !oncpu(c) && !spectral && !c.envelope + streams = plasma === nothing ? 2 : 6 + half = streams ÷ 2 + pack_in, pack_out = dzeros(c, R, nt, streams * nm), dzeros(c, C, nf, streams * nm) + block(a, j) = view(a, :, (j-1)*nm+1:j*nm) + fine = block(pack_out, 1) + projected, projected_coarse = block(pack_in, 1), block(pack_in, half + 1) + coarse_spec = block(pack_out, half + 1) + if plasma !== nothing + plasma = merge(plasma, (projected=block(pack_in, 2), edge_projected=block(pack_in, 3), + coarse=block(pack_in, 5), coarse_edge=block(pack_in, 6), + spectrum=block(pack_out, 2), edge_spectrum=block(pack_out, 3), + coarse_spectrum=block(pack_out, 5), + coarse_edge_spectrum=block(pack_out, 6))) + end + source_in, source_out = view(pack_in, :, 1:half*nm), view(pack_out, :, 1:half*nm) + pack = (input=pack_in, output=pack_out, source_in=source_in, source_out=source_out, + source=plan(c, plan_rfft, source_in, 1), all=plan(c, plan_rfft, pack_in, 1)) + else + projected = dzeros(c, R, nt, spectral ? 0 : nm) + projected_coarse = dzeros(c, R, nt, spectral ? 0 : nm) + coarse_spec = similar(fine) + end work = ( node_band=node_band, node_fine=node_fine, band_source=dzeros(c, C, spectral ? nw : 0, spectral ? nm : 0), band_coarse=dzeros(c, C, spectral ? nw : 0, spectral ? nm : 0), @@ -87,14 +116,14 @@ function create_modal(c, host) absorber_spec_band=dzeros(c, C, spectral && in_stage ? nw : 0, spectral && in_stage ? nm : 0), adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), forward_stage=Ref{Any}(nothing), statistics=Ref{Any}(nothing), - raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma_workspace(c, host, nt, chunk, nm, nn), + raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma, pack=pack, y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), stages=dzeros(c, C, nw, nm, ns), forward=dzeros(c, C, nw, nm, ns), inverse=dzeros(c, C, nw, nm, ns), fine=fine, modal=modal, nodes=nodes, analytic=analytic, analytic_modes=analytic_modes, analytic_modes_inverse=from_spectrum ? plan(c, plan_bfft!, analytic_modes, 1) : nothing, - projected=dzeros(c, R, nt, spectral ? 0 : nm), projected_coarse=dzeros(c, R, nt, spectral ? 0 : nm), - coarse_spec=similar(fine), absorber=dzeros(c, R, nt, spectral ? 0 : nm), absorber_spec=similar(fine), + projected=projected, projected_coarse=projected_coarse, + coarse_spec=coarse_spec, absorber=dzeros(c, R, nt, spectral ? 0 : nm), absorber_spec=similar(fine), coarse=coarse, inverse_plan=c.envelope ? plan(c, plan_bfft, fine, 1) : plan(c, plan_brfft, fine, nt, 1), forward_plan=c.envelope ? plan(c, plan_fft, modal, 1) : plan(c, plan_rfft, modal, 1), @@ -183,7 +212,18 @@ function source!(engine, lab; quadrature=false) gemm!(w.projected_coarse, nodes, table_rows(c, c.projection_coarse, first, last), true, true, c) end end - if w.plasma === nothing + if w.pack !== nothing + # One transform: the source's streams, and with the quadrature its coarse ones, + # whose spectrum is assembled here for the alarm (`alarm_arrays`). + k = w.pack + coarse = quadrature && c.embedded + @section :forward_fft coarse ? mul!(k.output, k.all, k.input) : + mul!(k.source_out, k.source, k.source_in) + if w.plasma !== nothing + @section :plasma_spectrum add_plasma_spectra!(w.fine, w.plasma, c) + coarse && add_plasma_spectra!(w.coarse_spec, w.plasma, c; coarse=true) + end + elseif w.plasma === nothing @section :forward_fft mul!(w.fine, w.forward_plan, w.projected) else # The source's and the currents' transforms as one pool's work. diff --git a/julia/src/responses.jl b/julia/src/responses.jl index b46f05c09..6e4a49eed 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -423,8 +423,11 @@ function add_plasma!(destination, p, plan, c; coarse=false, direct=false) add_plasma_spectra!(destination, p, c) end """Add `-i J / omega + edge / omega^2` of the currents' spectra, already transformed.""" -function add_plasma_spectra!(destination, p, c) - (; spectrum, edge_spectrum, inverse_omega) = p +function add_plasma_spectra!(destination, p, c; coarse=false) + # The coarse quadrature's currents (a GPU's packed streams), or the source's. + spectrum, edge_spectrum = coarse ? (p.coarse_spectrum, p.coarse_edge_spectrum) : + (p.spectrum, p.edge_spectrum) + inverse_omega = p.inverse_omega crop, mask = c.crop, c.mask each!(c, length(crop), size(destination, 2)) do f, m @inbounds if mask[f] From 9551c9a5c207b6398abe5ab396b5f333776e9c8b Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 20:16:37 +0000 Subject: [PATCH 082/107] Julia: a GPU free-space source's polarisation and currents in one transform [skip ci] On a GPU the free-space source's projected polarisation and the plasma's two currents are column blocks of one buffer, transformed together: three forward transforms a source were one each (line: eighteen a DOPRI step -> six). A CPU keeps its plans. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/free.jl | 27 +++++++++++++++++++++++---- 1 file changed, 23 insertions(+), 4 deletions(-) diff --git a/julia/src/free.jl b/julia/src/free.jl index 32292e41f..7d7210b90 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -51,15 +51,29 @@ function create_free(c, host) analytic = dzeros(c, C, nt, chunk) coarse, coarse_spec = dzeros(c, R, nc, chunk), dzeros(c, C, nw, chunk) planes = (threads=c.transverse_fft_threads, batch=1) + # On a GPU the projected polarisation and the plasma's two currents are column + # blocks of one buffer, transformed together (three transforms a source were one + # each, through the device's FFT library between the engine's kernels). + plasma = plasma_workspace(c, host, nt, chunk, chunk, nm) + projected = dzeros(c, R, nt, chunk) + pack = nothing + if !oncpu(c) && plasma !== nothing && !c.envelope + pack_in, pack_out = dzeros(c, R, nt, 3chunk), dzeros(c, C, nf, 3chunk) + block(a, j) = view(a, :, (j-1)*chunk+1:j*chunk) + projected, fine = block(pack_in, 1), block(pack_out, 1) + plasma = merge(plasma, (gated=block(pack_in, 2), edge=block(pack_in, 3), + spectrum=block(pack_out, 2), edge_spectrum=block(pack_out, 3))) + pack = (input=pack_in, output=pack_out, forward=plan(c, plan_rfft, pack_in, 1)) + end work = ( adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), - plasma=plasma_workspace(c, host, nt, chunk, chunk, nm), + plasma=plasma, pack=pack, y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), stages=dzeros(c, C, nw, nm, stages), forward=dzeros(c, C, nw, nm, 1), inverse=dzeros(c, C, nw, nm, c.low_storage ? 0 : 1), physical=physical, loss=dzeros(c, C, in_stage ? nw : 0, in_stage ? nm : 0), - fine=fine, modal=modal, projected=dzeros(c, R, nt, chunk), analytic=analytic, + fine=fine, modal=modal, projected=projected, analytic=analytic, absorber=dzeros(c, R, nt, chunk), absorber_spec=similar(fine), coarse=coarse, coarse_spec=coarse_spec, spatial_inverse=plan(c, plan_bfft!, spatial, (2, 3); planes...), spatial_forward=plan(c, plan_fft!, spatial, (2, 3); planes...), @@ -211,10 +225,15 @@ function source_free!(engine, lab) @inbounds projected[t, m] = polarization(scale * modal[t, m], factor, a) * window[t] end end - mul!(fine, w.forward_plan, projected) # The held-current polarisation joins before the transverse forward transform, # as the reference Cartesian source does. - w.plasma === nothing || add_plasma!(fine, w.plasma, w.forward_plan, c; direct=true) + if w.pack !== nothing + mul!(w.pack.output, w.pack.forward, w.pack.input) + add_plasma_spectra!(fine, w.plasma, c) + else + mul!(fine, w.forward_plan, projected) + w.plasma === nothing || add_plasma!(fine, w.plasma, w.forward_plan, c; direct=true) + end c.in_stage && free_absorber!(w, c, first, count) gather_columns!(physical, fine, c.in_stage ? loss : nothing, w.absorber_spec, first, count, c) end From 970b5d13c8196ebd5774cfa5060c653d4ac1f852 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 20:26:19 +0000 Subject: [PATCH 083/107] Julia: lockstep batches, TSIT5 and modal RK4IP [skip ci] Three of the features the mlx backend runs and Julia refused: - Batches: select_batch returns the generic LockstepRunner for julia members (a fixed schedule, as every backend's batches need). Each member of a two-member batch of an ionising capillary matches numpy_ref within 1e-10. - TSIT5: the trial reads its tableau's rows, and TSIT5 is seven stages and first-same-as-last like DOPRI5; an adaptive window takes the reference's steps and field. - RK4IP on modal routes with a constant operator: the flow exp(h L / 2) in the wide type (modal_flow!). A varying operator stays refused. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/rk4.jl | 16 +++- src/solprop/backends/julia/_backend.py | 12 ++- src/solprop/backends/registry.py | 8 ++ tests/backends/test_julia.py | 115 +++++++++++++++++++++++++ 4 files changed, 146 insertions(+), 5 deletions(-) diff --git a/julia/src/rk4.jl b/julia/src/rk4.jl index a3a0455cb..9a9b79305 100644 --- a/julia/src/rk4.jl +++ b/julia/src/rk4.jl @@ -11,7 +11,7 @@ function rk4!(engine, dz::Float64, key::Float64) (; y, lab, candidate, error, source, forward) = w mask = c.norm_mask h, half, third, sixth = T(dz), T(dz / 2), T(dz / 3), T(dz / 6) - free_propagators!(engine, key / 2) + c.free ? free_propagators!(engine, key / 2) : modal_flow!(engine, key / 2) none = zero(T) source!(engine, y) each!(c, size(y)...) do f, m @@ -57,3 +57,17 @@ function rk4!(engine, dz::Float64, key::Float64) end (Float64(squared), lower > 0 ? 2sqrt(Float64(upper) / Float64(lower)) : NaN) end + +"""A modal route's RK4IP flow over `h`, `exp(h L)`, in slot one (formed in the wide type +and rounded once), kept while `h` is unchanged.""" +function modal_flow!(engine, h) + engine.propagator_dz == h && return 1 + c, w = engine.config, engine.work + linear, forward = c.linear, w.forward + step = wide_value(c, Float64(h)) + each!(c, size(linear)...) do f, m + @inbounds forward[f, m, 1] = first(wide_exp_pair(step * linear[f, m])) + end + engine.propagator_dz = h + 1 +end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 5bc56183b..1d6c55e30 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -51,7 +51,7 @@ default_spec, ) from solprop.stepper import LowStorageRungeKutta, Multistep -from solprop.stepper.tableau import DOPRI5 +from solprop.stepper.tableau import DOPRI5, TSIT5 from solprop.translate.chebyshev import PiecewiseChebyshev from solprop.translate.linop import power_weight_at from solprop.translate.precision import launch_peak, state_scale @@ -208,11 +208,15 @@ def _refuse(problem: KernelProblem) -> None: ), "Cartesian Adams integration": isinstance(stepper.integrator, Multistep) and transform.kind == "free", - "non-Cartesian low-storage integration": isinstance( + # A modal route's RK4IP flow is the constant operator's exponential; a + # varying one's (an integral over the half step) is not formed. + "low-storage integration with a varying operator": isinstance( stepper.integrator, LowStorageRungeKutta ) - and transform.kind != "free", - "non-DOPRI5 tableau": stepper.tableau is not DOPRI5, + and transform.kind != "free" + and _varying(problem), + # The trial reads its tableau's rows; both are 7-stage first-same-as-last. + "tableaux other than DOPRI5 and TSIT5": stepper.tableau not in (DOPRI5, TSIT5), "interpolated planes": stepper.interpolate_planes, } if ( diff --git a/src/solprop/backends/registry.py b/src/solprop/backends/registry.py index 6441b5e7f..ebc752fb6 100644 --- a/src/solprop/backends/registry.py +++ b/src/solprop/backends/registry.py @@ -589,6 +589,14 @@ def select_batch(owners: Sequence[Backend]) -> BatchBackend: return cast( BatchBackend, NativeBatchBackend(cast(Sequence[NativeBackend], owners)) ) + if name == "julia": + # The Julia experiment's members each step their own engine; the generic + # runner keeps them in lockstep. + from solprop.backends.batch import ( # noqa: PLC0415 - lazy backend + LockstepRunner, + ) + + return LockstepRunner(cast("Sequence[StepDriver[object]]", owners)) raise BackendError(f"Batch has no runner for backend {name!r}") diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 70fff2ab7..8d719ed32 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -121,6 +121,121 @@ def test_julia_matches_the_reference(runtime, case, stepper, fraction): @binary64 +def _fixed_capillary(backend, *, integrator=None, fixed=True): + """A short ionising capillary, on 16 fixed steps (a batch runs a fixed schedule) or + adaptive.""" + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length = 0.004 + schedule = FixedSchedule.uniform(0.0, length, length / 16) if fixed else None + return Simulation.from_capillary( + 50e-6, + length, + "Ar", + 1.0, + wavelength=800e-9, + wavelength_limits=(150e-9, 3e-6), + trange=300e-15, + fwhm=10e-15, + energy=60e-6, + n_save=2, + backend=backend, + integrator=RungeKutta() if integrator is None else integrator, + schedule=schedule, + absorber_scheme="split_step", + noise=None, + ) + + +@binary64 +def test_julia_modal_low_storage_matches_the_reference(runtime): + """RK4IP on a capillary (a modal route) replays the reference's schedule.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.stepper import LowStorageRungeKutta # noqa: PLC0415 + + stop, fields = 0.004, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = _fixed_capillary(name, integrator=LowStorageRungeKutta()) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(stop) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + +@binary64 +def test_julia_tsit5_matches_the_reference(runtime): + """An adaptive TSIT5 window takes the reference's steps and field.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.stepper import RungeKutta # noqa: PLC0415 + from solprop.stepper.tableau import TSIT5 # noqa: PLC0415 + + stop, observed = 0.004, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = _fixed_capillary( + name, integrator=RungeKutta(TSIT5), fixed=False + ) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(stop) + observation = engine.observe(field=True) + observed[name] = ( + observation.field, + observation.n_steps, + observation.n_rejected, + ) + field, steps, rejected = observed["julia"] + expected, expected_steps, expected_rejected = observed["numpy_ref"] + assert (steps, rejected) == (expected_steps, expected_rejected) + scale = float(np.linalg.norm(expected)) + assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale + + +def _loaded(simulation, name, cleanup): + """The simulation's backend, its launch loaded.""" + problem = simulation.translate() + engine = select( + name, + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + cleanup.callback(engine.close) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + return engine + + +@binary64 +def test_julia_batch_members_are_their_solo_runs(runtime): + """Lockstep members (`select_batch`) match their solo runs and the reference.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.backends.registry import select_batch # noqa: PLC0415 + + stop = 0.004 + with ExitStack() as cleanup: + reference = _loaded(_fixed_capillary("numpy_ref"), "numpy_ref", cleanup) + reference.propagate_to(stop) + expected = reference.observe(field=True).field + members = [ + _loaded(_fixed_capillary("julia"), "julia", cleanup) for _ in range(2) + ] + runner = select_batch(members) + runner.propagate_to(stop) + fields = [member.field for member in runner.observe_members()] + scale = float(np.linalg.norm(expected)) + for field in fields: + assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale + + def test_julia_reports_its_engine(runtime): """Metadata names the runtime and the sources; the ledger counts owned arrays.""" del runtime From b0155d2c5981e0fb08bc1087d34ef5c7d2eb1aca Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 20:34:31 +0000 Subject: [PATCH 084/107] Julia: several Raman components, summed into one kernel [skip ci] Each component's terms join one kernel, weighted by its density and fraction (constant coefficients; varying ones stay refused), the sum the mlx backend forms; components must agree on the third harmonic. Two components (air's term split into an N2 and an O2 half) match numpy_ref's two convolutions to 4e-15. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/responses.jl | 5 +- src/solprop/backends/julia/_backend.py | 29 +++++++---- tests/backends/test_julia.py | 71 ++++++++++++++++++++++++++ 3 files changed, 95 insertions(+), 10 deletions(-) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 6e4a49eed..d569a54ee 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -567,9 +567,12 @@ function raman_workspace(c, host, nt, chunk; modes=0, nodes=0, synthesis=nothing T, C = c.T, Complex{c.T} rows, rates = host.array("raman_undamped", Float64), host.array("raman_rates", Float64) dt = host.real("dt") + # Each term weighted by its component's density and fraction (several components, + # summed into one kernel), or all by one if the adapter gives none. + weights = host.has("raman_weights") ? host.array("raman_weights", Float64) : ones(length(rates)) kernel = zeros(2nt) for term in eachindex(rates), t in 1:2nt - kernel[t] += rows[t, term] * exp(-rates[term] * (t - 1) * dt) + kernel[t] += weights[term] * rows[t, term] * exp(-rates[term] * (t - 1) * dt) end kernel .*= host.real("raman_fraction") # The inverse transform is unnormalised: its 1/(2 nt) is folded into the kernel. diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 1d6c55e30..39a1f562f 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -186,7 +186,12 @@ def _refuse(problem: KernelProblem) -> None: "nonseparable longitudinal tables": not terms(problem).device_ready, "varying radius": transform.taper_scale is not None, "multiple plasma channels": len(response.plasma_channels) > 1, - "multiple Raman components": len(response.raman_terms) > 1, + # Several components sum into one kernel (each term weighted by its density + # and fraction); they must agree on the third harmonic. + "Raman components that disagree on the third harmonic": len( + {r.thg for r in response.raman_terms} + ) + > 1, "varying Raman coefficients": any( not _constant(r.density or response.density) or any(not _constant(v) for v in r.decay_rates) @@ -430,15 +435,21 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: ) if responses.raman_terms: - raman = responses.raman_terms[0] + # Every component's terms in one kernel, each weighted by its density and + # fraction (constant: varying coefficients are refused), the mlx backend's sum. + rows, rates, weights = [], [], [] + for raman in responses.raman_terms: + density = float((raman.density or responses.density)(0.0)) + rows.append(raman.undamped.T) + rates.extend(float(rate(0.0)) for rate in raman.decay_rates) + weights.extend([density * raman.fraction] * len(raman.decay_rates)) config.update( - raman_undamped=raman.undamped.T.copy(), - raman_rates=np.array([float(rate(0.0)) for rate in raman.decay_rates]), - raman_fraction=raman.fraction, - raman_factor=EPS0 - * float((raman.density or responses.density)(0.0)) - * scale**2, - raman_thg=raman.thg, + raman_undamped=np.ascontiguousarray(np.hstack(rows)), + raman_rates=np.array(rates), + raman_weights=np.array(weights), + raman_fraction=1.0, + raman_factor=EPS0 * scale**2, + raman_thg=responses.raman_terms[0].thg, dt=grids.dt_fine, ) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 8d719ed32..e36f2152b 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -167,6 +167,77 @@ def test_julia_modal_low_storage_matches_the_reference(runtime): assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale +# The band reaches below O2's qualified dispersion range; the warning says so and is +# not this test's subject. +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@binary64 +def test_julia_two_raman_components_match_the_reference(runtime): + """Two Raman components (air's, split into an N2 and an O2 half) sum into the + engine's one kernel and match the reference's two convolutions.""" + del runtime + import dataclasses # noqa: PLC0415 + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + from solprop.translate.problem import Flags # noqa: PLC0415 + + length = 0.004 + simulation = Simulation.from_capillary( + 50e-6, + length, + {"N2": 0.79, "O2": 0.21}, + 1.0, + wavelength=800e-9, + wavelength_limits=(200e-9, 3e-6), + trange=300e-15, + fwhm=10e-15, + energy=40e-6, + n_save=2, + backend="numpy_ref", + plasma=False, + raman=True, + noise=None, + integrator=RungeKutta(), + absorber_scheme="split_step", + schedule=FixedSchedule.uniform(0.0, length, length / 16), + ) + problem = simulation.translate() + (term,) = problem.responses.raman_terms + terms = tuple( + dataclasses.replace(term, fraction=term.fraction / 2, label=label) + for label in ("N2", "O2") + ) + responses = dataclasses.replace(problem.responses, raman_terms=terms) + problem = dataclasses.replace( + problem, + responses=responses, + flags=Flags.from_content( + shape=problem.shape, + linear=problem.linear, + transform=problem.transform, + responses=responses, + initial=problem.initial, + ), + ) + fields = {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + engine = select( + name, + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + cleanup.callback(engine.close) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(length) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + @binary64 def test_julia_tsit5_matches_the_reference(runtime): """An adaptive TSIT5 window takes the reference's steps and field.""" From e316b7bf690907a3084da795b2673c6e2f099e51 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 20:46:40 +0000 Subject: [PATCH 085/107] Julia: tapered guides [skip ci] The adapter binds the transform's taper scale tau(z) as a stage table; the engine reads it as a fourth material row, and every synthesis takes tau, every projection 1/tau and the Raman modal products' nodal drive tau^2, as the reference's passes scale them. A 20 % radius taper with a pressure gradient on ten fixed steps (the native test's case) matches numpy_ref to 6e-15; the stage scalar test compares the taper row with the bundles bit for bit. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/SolpropJulia.jl | 3 ++ julia/src/free.jl | 2 +- julia/src/launch.jl | 2 ++ julia/src/modal.jl | 22 ++++++------ julia/src/responses.jl | 10 +++--- julia/src/stages.jl | 6 ++-- src/solprop/backends/julia/_backend.py | 5 ++- tests/backends/test_julia.py | 47 ++++++++++++++++++++++++++ 8 files changed, 77 insertions(+), 20 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 25bc5023e..50f4fcbfa 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -36,6 +36,9 @@ mutable struct Engine{C,W} # handed to the commit that follows, so that the commit waits for nothing. alarm::Float64 alarm_ready::Bool + # A tapered guide's scale at the stage, tau(z): the synthesis takes it, the + # projection its reciprocal (`transform.taper_scale`); one without a taper. + taper::Float64 end include("launch.jl") diff --git a/julia/src/free.jl b/julia/src/free.jl index 7d7210b90..9691907ad 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -83,7 +83,7 @@ function create_free(c, host) coarse_inverse=c.envelope ? plan(c, plan_bfft, coarse_spec, 1) : plan(c, plan_brfft, coarse_spec, nc, 1), coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), ) - Engine(c, work, false, 0, NaN, c.factor, NaN, false) + Engine(c, work, false, 0, NaN, c.factor, NaN, false, 1.0) end # For an exactly real squared longitudinal wave number the principal root is sqrt(x) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 3c0e5d6c5..e80e77a9d 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -340,6 +340,8 @@ and in binary32 not safe to run from several tasks (a 1.5 relative error on the LinearAlgebra in Julia 1.13.3). """ function gemm!(C, A, B, alpha, beta, c) + # A scale (a taper's) at the arrays' precision: an Apple GPU takes no binary64. + alpha isa Bool || (alpha = real(eltype(C))(alpha)) if eltype(C) <: Complex && eltype(A) <: Complex && eltype(B) <: Real return gemm!(real_rows(C), real_rows(A), B, alpha, beta, c) end diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 20a302f4a..51239a461 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -131,7 +131,7 @@ function create_modal(c, host) coarse_inverse=c.envelope ? plan(c, plan_bfft, band, 1) : plan(c, plan_brfft, band, c.nc, 1), coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), ) - Engine(c, work, false, 0, NaN, c.factor, NaN, false) + Engine(c, work, false, 0, NaN, c.factor, NaN, false, 1.0) end """The modes' analytic signals from their half spectrum `fine`: the one-sided spectrum @@ -194,22 +194,22 @@ function source!(engine, lab; quadrature=false) # The nodes' analytic signal by the synthesis, the field its real part. analytic = @view w.analytic[:, 1:count] @section :synthesis gemm!(analytic, w.analytic_modes, @view(c.synthesis[:, first:last]), - true, false, c) + engine.taper, false, c) each!(c, size(analytic)...) do t, m @inbounds nodes[t, m] = real(analytic[t, m]) end else - @section :synthesis gemm!(nodes, w.modal, @view(c.synthesis[:, first:last]), true, false, c) + @section :synthesis gemm!(nodes, w.modal, @view(c.synthesis[:, first:last]), engine.taper, false, c) end if w.plasma !== nothing @section :plasma plasma_current!(w.plasma, w.nodes, c, count) - @section :plasma_projection project_plasma!(w.plasma, c, first, last, quadrature) + @section :plasma_projection project_plasma!(w.plasma, c, first, last, quadrature, 1 / engine.taper) end - products && @section :raman raman_nodal!(w.raman, first, last, c) + products && @section :raman raman_nodal!(w.raman, first, last, c, engine.taper^2) node_response!(engine, count) - @section :projection gemm!(w.projected, nodes, table_rows(c, c.projection, first, last), true, true, c) + @section :projection gemm!(w.projected, nodes, table_rows(c, c.projection, first, last), 1 / engine.taper, true, c) quadrature && c.embedded && - gemm!(w.projected_coarse, nodes, table_rows(c, c.projection_coarse, first, last), true, true, c) + gemm!(w.projected_coarse, nodes, table_rows(c, c.projection_coarse, first, last), 1 / engine.taper, true, c) end end if w.pack !== nothing @@ -314,7 +314,7 @@ function source_spectral!(engine, lab, quadrature) last = min(first + chunk - 1, nn) count = last - first + 1 band = @view node_band[:, 1:count] - @section :synthesis gemm!(band, lab, @view(c.synthesis[:, first:last]), true, false, c) + @section :synthesis gemm!(band, lab, @view(c.synthesis[:, first:last]), engine.taper, false, c) if c.analytic @section :analytic begin each!(c, nt, chunk) do k, m @@ -345,9 +345,9 @@ function source_spectral!(engine, lab, quadrature) @section :forward_fft mul!(node_fine, w.node_forward, nodes) @section :plasma_spectrum spectral_plasma!(node_band, node_fine, w.plasma, w.node_forward, c) @section :projection begin - gemm!(band_source, band, table_rows(c, c.projection, first, last), true, true, c) + gemm!(band_source, band, table_rows(c, c.projection, first, last), 1 / engine.taper, true, c) quadrature && c.embedded && - gemm!(band_coarse, band, table_rows(c, c.projection_coarse, first, last), true, true, c) + gemm!(band_coarse, band, table_rows(c, c.projection_coarse, first, last), 1 / engine.taper, true, c) end end loss = nothing @@ -421,7 +421,7 @@ function population_snapshot(engine, input) for first in 1:chunk:nn last = min(first + chunk - 1, nn) count = last - first + 1 - gemm!(@view(w.nodes[:, 1:count]), w.modal, @view(c.synthesis[:, first:last]), true, false, c) + gemm!(@view(w.nodes[:, 1:count]), w.modal, @view(c.synthesis[:, first:last]), engine.taper, false, c) maxima .= max.(maxima, population_parts!(p, w.nodes, c, first, count)) end (Vector{Float64}(Array(p.fractions)), Vector{Float64}(Array(p.peaks)), maxima) diff --git a/julia/src/responses.jl b/julia/src/responses.jl index d569a54ee..b02a37353 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -406,13 +406,13 @@ end clear_plasma!(::Nothing) = nothing clear_plasma!(p) = foreach(a -> fill!(a, 0), (p.projected, p.edge_projected, p.coarse, p.coarse_edge)) -function project_plasma!(p, c, first, last, quadrature) +function project_plasma!(p, c, first, last, quadrature, alpha=true) count = last - first + 1 for (values, full, coarse) in ((p.gated, p.projected, p.coarse), (p.edge, p.edge_projected, p.coarse_edge)) block = @view values[:, 1:count] - gemm!(full, block, table_rows(c, c.projection, first, last), true, true, c) + gemm!(full, block, table_rows(c, c.projection, first, last), alpha, true, c) quadrature && c.embedded && - gemm!(coarse, block, table_rows(c, c.projection_coarse, first, last), true, true, c) + gemm!(coarse, block, table_rows(c, c.projection_coarse, first, last), alpha, true, c) end end @@ -651,6 +651,6 @@ function raman_products!(r, modal, c; signal=nothing) end """A chunk's convolved node drives, rebuilt from the convolved products.""" -raman_nodal!(r, first, last, c) = +raman_nodal!(r, first, last, c, alpha=true) = gemm!(@view(r.nodal[:, 1:last-first+1]), @view(r.drive[1:size(r.nodal, 1), :]), - @view(r.weights[:, first:last]), true, false, c) + @view(r.weights[:, first:last]), alpha, false, c) diff --git a/julia/src/stages.jl b/julia/src/stages.jl index 5c72696a0..f1efe33dc 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -14,7 +14,7 @@ function path_workspace(c, host) (phi=upload(c, phi), prefactor=upload(c, pre), delta=zeros(size(phi, 3), stages), weights=zeros(size(pre, 3), stages), delta_device=dzeros(c, wide_eltype(c), size(phi, 3), stages), - weights_device=dzeros(c, c.T, size(pre, 3), stages), material=zeros(3, stages), + weights_device=dzeros(c, c.T, size(pre, 3), stages), material=[zeros(3, stages); ones(1, stages)], tables=Dict{String,Any}(), constants=zeros(4)) end @@ -45,6 +45,7 @@ function material_stage!(engine, stage) @inbounds prefactor[f, m] = value end engine.factor = p.material[1, stage] + engine.taper = p.material[4, stage] if w.plasma !== nothing w.plasma.parameters[8] = p.material[2, stage] w.plasma.parameters[9] = p.material[3, stage] @@ -122,8 +123,9 @@ function configure_stages_at!(engine, z0, positions) end column(name) = haskey(tables, name) ? stage_values(tables[name], zs)[:, 1] : zeros(n) density = column("kerr") + taper = haskey(tables, "taper") ? stage_values(tables["taper"], zs)[:, 1] : ones(n) material = permutedims(hcat([kerr * d * scale2 for d in density], - column("plasma"), column("preionisation"))) + column("plasma"), column("preionisation"), taper)) configure_stages!(engine, delta, weights, material) end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 39a1f562f..52b997885 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -184,7 +184,6 @@ def _refuse(problem: KernelProblem) -> None: "planar transforms": transform.geometry is not None and transform.geometry.kind not in {"radial", "free"}, "nonseparable longitudinal tables": not terms(problem).device_ready, - "varying radius": transform.taper_scale is not None, "multiple plasma channels": len(response.plasma_channels) > 1, # Several components sum into one kernel (each term weighted by its density # and fraction); they must agree on the third harmonic. @@ -818,6 +817,10 @@ def _bind_stage_tables(self) -> None: for channel in responses.population_channels[:1]: tables["plasma"] = channel.density tables["preionisation"] = channel.preionisation + if problem.transform.taper_scale is not None: + # A tapered guide's scale: the synthesis takes it, the projection its + # reciprocal. + tables["taper"] = problem.transform.taper_scale for name, table in tables.items(): call_julia(self._jl.bind_stage_table_b, self._engine, name, *table.packed()) low, high = ( diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index e36f2152b..188394bc8 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -238,6 +238,52 @@ def test_julia_two_raman_components_match_the_reference(runtime): assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.filterwarnings("ignore::solprop.exceptions.GasFlowWarning") +@binary64 +def test_julia_taper_matches_the_reference(runtime): + """A 20 % radius taper with a pressure gradient: the synthesis scaled by the taper, + the projection by its reciprocal, on ten fixed steps (the native test's case).""" + del runtime + from dataclasses import replace # noqa: PLC0415 + + from solprop.boundaries import absorber # noqa: PLC0415 + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.profiles import Linear # noqa: PLC0415 + from solprop.stepper import FixedSchedule # noqa: PLC0415 + + length = 0.1 + + def field(backend): + simulation = Simulation.from_capillary( + Linear(100e-6, 80e-6, length), + length, + "Ar", + (5.0, 0.2), + wavelength=800e-9, + fwhm=30e-15, + energy=10e-6, + wavelength_limits=(300e-9, 2e-6), + trange=400e-15, + noise=None, + vacuum_end="floor", + plasma=False, + n_save=3, + backend=backend, + schedule=FixedSchedule(np.full(10, length / 10)), + ) + simulation.settings = replace( + simulation.settings, + absorber=absorber(simulation.grid, boundary_length=10.0), + boundary_check=None, + ) + return np.asarray(simulation.run()["field"])[-1] + + expected, ours = field("numpy_ref"), field("julia") + scale = float(np.linalg.norm(expected)) + assert float(np.linalg.norm(ours - expected)) <= 1e-10 * scale + + @binary64 def test_julia_tsit5_matches_the_reference(runtime): """An adaptive TSIT5 window takes the reference's steps and field.""" @@ -549,6 +595,7 @@ def test_julia_stage_scalars_are_the_bundles_bit_for_bit(runtime): 0.0 if kerr is None else kerr.coefficient * b.kerr_density, b.plasma_densities[0] if b.plasma_densities else 0.0, b.preionisation, + b.taper_scale, ] for b in bundles ] From 96c3e21e475db2860f6c46f5abf7074cd1171de5 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 20:50:25 +0000 Subject: [PATCH 086/107] Julia: the window statistics and the zero-dispersion wavelength [skip ci] energy_window, peak_power_window and zdw on guided routes, which the shared host functions form from the state: they match numpy_ref to 3e-16 on an rdw window. The on-axis plasma statistics stay refused (they need the populations on an on-axis node). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- src/solprop/backends/julia/_backend.py | 10 +++++-- tests/backends/test_julia.py | 41 ++++++++++++++++++++++++++ 2 files changed, 49 insertions(+), 2 deletions(-) diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 52b997885..dee87cc4a 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -78,13 +78,19 @@ "plasma_boundary_level", ) ) +# Beyond the defaults, the statistics the shared host functions form from the state +# alone (the windows, the zero-dispersion wavelength, a spatial run's temporal ones). +_HOST_STATS = frozenset(("energy_window", "peak_power_window")) _SUPPORTED_STATS = ( frozenset(default_spec("multimode", with_profiles=True).names) | _SPECIES_STATS - | {"peak_intensity", "quadrature_error"} + | _HOST_STATS + | {"peak_intensity", "quadrature_error", "zdw"} ) _SPATIAL_STATS = ( - frozenset(default_spec("radial", with_profiles=True).names) | _SPECIES_STATS + frozenset(default_spec("radial", with_profiles=True).names) + | _SPECIES_STATS + | _HOST_STATS ) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 188394bc8..d653f67be 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -284,6 +284,47 @@ def field(backend): assert float(np.linalg.norm(ours - expected)) <= 1e-10 * scale +@binary64 +def test_julia_window_statistics_match_the_reference(runtime): + """The energy and peak power in a band and the zero-dispersion wavelength, which the + shared host functions form from the state, as the reference forms them.""" + del runtime + import dataclasses # noqa: PLC0415 + + names = ("energy_window", "peak_power_window", "zdw") + configuration = CASES["rdw"].configuration( + "default", 2, "julia", fraction=0.002, noise="none" + ) + values = {} + for name in ("numpy_ref", "julia"): + simulation = build(configuration | {"backend": name}) + problem = simulation.translate() + spec = dataclasses.replace( + problem.stats_spec, names=names, energy_windows=np.array([[1.5e15, 3.0e15]]) + ) + engine = select( + name, + problem, + grid=simulation.grid, + modes=simulation.modes, + profiles=simulation.profiles, + ) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(float(configuration["stop"])) + values[name] = engine.stats(spec) + engine.close() + for statistic in names: + expected = np.asarray(values["numpy_ref"][statistic]) + largest = float(np.max(np.abs(expected), initial=0.0)) + np.testing.assert_allclose( + values["julia"][statistic], + expected, + rtol=1e-9, + atol=1e-9 * largest, + err_msg=statistic, + ) + + @binary64 def test_julia_tsit5_matches_the_reference(runtime): """An adaptive TSIT5 window takes the reference's steps and field.""" From 7c85fc7ace053789884bffa33ef3f60554381205 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 20:59:23 +0000 Subject: [PATCH 087/107] Julia: resolved and radial envelopes, and the envelope's third harmonic [skip ci] The engine already held the complex buffers and plans an envelope grid needs; the refusal of resolved modal and radial envelopes is lifted, with the complex-by-real products through the real view. The envelope's third-harmonic term, factor h exp(2 i w0 t) E^2 E, joins nonlinear_envelope! and the free-space envelope source (the adapter passes the factor and grids.carrier_2w0). Against numpy_ref: four resolved modes 3e-15 (2e-15 with the harmonic), a radial envelope beam 2e-16. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/SolpropJulia.jl | 1 + julia/src/free.jl | 8 ++- julia/src/modal.jl | 1 + julia/src/responses.jl | 6 ++ src/solprop/backends/julia/_backend.py | 10 +-- tests/backends/test_julia.py | 92 ++++++++++++++++++++++++++ 6 files changed, 112 insertions(+), 6 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 50f4fcbfa..1b9eda9e1 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -97,6 +97,7 @@ function create(input) envelope=host.flag("envelope"), low_storage=host.flag("low_storage"), free=host.flag("free"), split=host.flag("split"), analytic=host.flag("analytic"), analytic_factor=T(host.real("analytic_factor")), factor=host.real("factor"), + harmonic=T(host.has("harmonic_factor") ? host.real("harmonic_factor") : 0.0), rtol=host.real("rtol"), atol=host.real("atol"), cache_propagators=host.has("cache_propagators") ? host.flag("cache_propagators") : true, # A binary32 state is held as a / s, s an exact power of two (SEP 33, rule 2). diff --git a/julia/src/free.jl b/julia/src/free.jl index 9691907ad..1c71372c2 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -208,10 +208,16 @@ function source_free!(engine, lab) plasma_current!(w.plasma, projected, c, count) end if c.envelope + h, carrier = factor * c.harmonic, c.carrier + harmonic = !iszero(h) each!(c, size(modal)...) do t, m @inbounds begin v = scale * modal[t, m] - projected[t, m] = factor * a * abs2(v) * v * window[t] + response = factor * a * abs2(v) * v + if harmonic + response += h * carrier[t] * (v * v) * v + end + projected[t, m] = response * window[t] end end elseif c.analytic diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 51239a461..6f1a0128b 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -19,6 +19,7 @@ function common_tables(c, host) mask=upload(c, host.array("mask", Bool)), norm_mask=upload(c, host.array("norm_mask", Bool)), weights=upload(c, host.array("weights", T)), uniform=all(==(1), host.array("weights", Float64)), window=upload(c, host.array("window", T)), omega_window=upload(c, host.array("omega_window", T)), + carrier=upload(c, host.has("carrier") ? host.array("carrier", Complex{T}) : zeros(Complex{T}, 0)), rate=host.array("rate", Float64), coarse_rate=host.array("coarse_rate", Float64), a=host.array("a", Float64), b=host.array("b", Float64), e=host.array("e", Float64), nodes_c=host.array("c", Float64), nt=nt, nf=nf, diff --git a/julia/src/responses.jl b/julia/src/responses.jl index b02a37353..4b6998301 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -39,10 +39,16 @@ function nonlinear_envelope!(nodes, c, factor, raman, count) r = raman === nothing ? zero(T) : T(raman.factor) drive = raman === nothing ? nodes : raman.drive live = raman !== nothing + # The third harmonic's term, factor h exp(2 i w0 t) E^2 E, where one is compiled. + h, carrier = T(factor) * c.harmonic, c.carrier + harmonic = !iszero(h) each!(c, size(nodes, 1), count) do t, m @inbounds begin v = nodes[t, m] response = f * abs2(v) * v + if harmonic + response += h * carrier[t] * (v * v) * v + end if live response = muladd(r * v, real(drive[t, m]), response) end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index dee87cc4a..353f3e1e1 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -179,11 +179,6 @@ def _refuse(problem: KernelProblem) -> None: ) reasons = { "envelope plasma": problem.grid_kind == "envelope" and problem.flags.has_plasma, - "resolved modal or radial envelopes": problem.grid_kind == "envelope" - and transform.kind not in {"free", "mode_averaged"}, - "envelope harmonics": problem.grid_kind == "envelope" - and response.kerr_coefficients is not None - and response.kerr_coefficients.harmonic_factor != 0, "single batch and scalar polarisation": problem.shape[0] != 1 or problem.shape[2] != 1 or transform.n_pol != 1, @@ -383,6 +378,11 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: "c": tableau.nodes.copy(), "factor": factor, "analytic": kerr is not None and kerr.analytic_signal, + # The envelope's third-harmonic term: its factor and the carrier exp(2 i w0 t). + "harmonic_factor": 0.0 if kerr is None else float(kerr.harmonic_factor), + "carrier": np.zeros(0, dtype=complex) + if problem.grids.carrier_2w0 is None + else problem.grids.carrier_2w0.copy(), "analytic_factor": 0.0 if kerr is None else kerr.self_factor + kerr.conjugate_factor, diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index d653f67be..d0127a5a0 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -325,6 +325,98 @@ def test_julia_window_statistics_match_the_reference(runtime): ) +@pytest.mark.parametrize("thg", [False, True]) +@binary64 +def test_julia_resolved_envelopes_match_the_reference(runtime, thg): + """Four resolved modes on the envelope grid, with and without the third harmonic's + carrier term.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length, fields = 0.004, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = Simulation.from_capillary( + 50e-6, + length, + "Ar", + 1.0, + wavelength=800e-9, + wavelength_limits=(150e-9, 3e-6), + trange=300e-15, + fwhm=10e-15, + energy=60e-6, + n_save=2, + backend=name, + integrator=RungeKutta(), + schedule=FixedSchedule.uniform(0.0, length, length / 16), + absorber_scheme="split_step", + noise=None, + envelope=True, + plasma=False, + thg=thg, + modes=4, + ) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + +@binary64 +def test_julia_radial_envelope_matches_the_reference(runtime): + """A self-focusing Kerr beam on the radial route's envelope grid.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from legacy_geometry import LEGACY_GRID, bare_absorber # noqa: PLC0415 + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.driver.simulation import SimulationSettings # noqa: PLC0415 + from solprop.grid import EnvelopeGrid, RadialGrid # noqa: PLC0415 + from solprop.nonlinear.responses import KerrResponse # noqa: PLC0415 + from solprop.pulses import GaussianPulse, SpatialPulse # noqa: PLC0415 + from solprop.spatial import SpatialMedium # noqa: PLC0415 + from solprop.stepper import FixedSchedule, PIController, RungeKutta # noqa: PLC0415 + + length, fields = 0.1, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + grid = EnvelopeGrid.from_limits( + length, 800e-9, (600e-9, 1.2e-6), 150e-15, thg=False, **LEGACY_GRID + ) + settings = SimulationSettings( + controller=PIController(rtol=1e-6, atol=0.0), + save_planes=[length], + dz_max=length, + dz_init=length / 10, + schedule=FixedSchedule.uniform(0.0, length, length / 10), + backend=name, + integrator=RungeKutta(), + absorber=bare_absorber(grid), + ) + pulse = SpatialPulse( + GaussianPulse(wavelength=800e-9, fwhm=50e-15, energy=3e-4), 300e-6 + ) + simulation = Simulation.from_radial( + grid, + RadialGrid(2e-3, 32), + SpatialMedium(), + [KerrResponse(1e-25, thg=False)], + pulse, + settings=settings, + noise=None, + ) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + @binary64 def test_julia_tsit5_matches_the_reference(runtime): """An adaptive TSIT5 window takes the reference's steps and field.""" From 82dcffe8c86f74f31b4a34ed3583cbf3733dae56 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 21:06:13 +0000 Subject: [PATCH 088/107] Julia: Raman in free space [skip ci] The free-space source forms the physical field once (the plasma reads it), then the responses in place as a modal source's nodes take them: the Raman drive from the field or its analytic signal, the envelope or field-grid Kerr with Raman. Without Raman the arithmetic is unchanged. On a line, envelope and field grids (with and without the third harmonic) take numpy_ref's steps, fields within 3e-16. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/free.jl | 40 ++++++----------- src/solprop/backends/julia/_backend.py | 1 - tests/backends/test_julia.py | 61 ++++++++++++++++++++++++++ 3 files changed, 75 insertions(+), 27 deletions(-) diff --git a/julia/src/free.jl b/julia/src/free.jl index 1c71372c2..3e6ce2797 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -66,7 +66,7 @@ function create_free(c, host) pack = (input=pack_in, output=pack_out, forward=plan(c, plan_rfft, pack_in, 1)) end work = ( - adams=nothing, path=nothing, raman=nothing, monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), + adams=nothing, path=nothing, raman=raman_workspace(c, host, nt, chunk), monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), plasma=plasma, pack=pack, y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), @@ -201,35 +201,23 @@ function source_free!(engine, lab) count = min(chunk, nm - first + 1) scatter_columns!(fine, physical, first, count, c) mul!(modal, w.inverse_plan, fine) - if w.plasma !== nothing - each!(c, size(modal)...) do t, m - @inbounds projected[t, m] = scale * modal[t, m] - end - plasma_current!(w.plasma, projected, c, count) + # The physical field, which the plasma reads, then the responses in place, as + # a modal source's nodes take them (`node_response!`). + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = scale * modal[t, m] end + w.plasma === nothing || plasma_current!(w.plasma, projected, c, count) + raman = w.raman if c.envelope - h, carrier = factor * c.harmonic, c.carrier - harmonic = !iszero(h) - each!(c, size(modal)...) do t, m - @inbounds begin - v = scale * modal[t, m] - response = factor * a * abs2(v) * v - if harmonic - response += h * carrier[t] * (v * v) * v - end - projected[t, m] = response * window[t] - end - end - elseif c.analytic - each!(c, size(modal)...) do t, m - @inbounds projected[t, m] = scale * modal[t, m] - end + raman === nothing || raman_drive!(raman, projected, projected, c, chunk) + nonlinear_envelope!(projected, c, factor, raman, chunk) + elseif c.analytic || (raman !== nothing && !raman.thg) analytic_signal!(analytic, projected, w.analytic_forward, w.analytic_inverse, c, chunk) - nonlinear_nodes!(projected, analytic, c, factor, nothing, chunk) + raman === nothing || raman_drive!(raman, projected, analytic, c, chunk) + nonlinear_nodes!(projected, c.analytic ? analytic : projected, c, factor, raman, chunk) else - each!(c, size(modal)...) do t, m - @inbounds projected[t, m] = polarization(scale * modal[t, m], factor, a) * window[t] - end + raman === nothing || raman_drive!(raman, projected, projected, c, chunk) + nonlinear_nodes!(projected, projected, c, factor, raman, chunk) end # The held-current polarisation joins before the transverse forward transform, # as the reference Cartesian source does. diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 353f3e1e1..f80f7f27e 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -197,7 +197,6 @@ def _refuse(problem: KernelProblem) -> None: or any(not _constant(v) for v in r.decay_rates) for r in response.raman_terms ), - "Cartesian Raman": problem.flags.has_raman and transform.kind == "free", "spectral responses": problem.flags.has_spectral_responses, "dispersive Kerr": response.dispersive_kerr is not None, "separable responses off free space": response.separable is not None diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index d0127a5a0..e9030288b 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -417,6 +417,67 @@ def test_julia_radial_envelope_matches_the_reference(runtime): assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale +@pytest.mark.parametrize( + ("grid_kind", "thg"), [("envelope", False), ("field", True), ("field", False)] +) +@binary64 +def test_julia_free_space_raman_matches_the_reference(runtime, grid_kind, thg): + """Kerr and one Raman term on a line (free space), on the envelope grid and on the + field grid with and without the third harmonic, as the reference evaluates them.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + from functools import partial # noqa: PLC0415 + + from backends.test_radial_nonlinear import LENGTH, make_problem # noqa: PLC0415 + from solprop.grid import EnvelopeGrid, FieldGrid, LineGrid # noqa: PLC0415 + from solprop.nonlinear.raman import ( # noqa: PLC0415 + DampedOscillator, + RamanResponse, + undamped_dephasing, + ) + from solprop.nonlinear.responses import KerrResponse # noqa: PLC0415 + from solprop.pulses import GaussianPulse, SpatialPulse # noqa: PLC0415 + from solprop.spatial import SpatialMedium # noqa: PLC0415 + + constructor = ( + FieldGrid.from_limits + if grid_kind == "field" + else partial(EnvelopeGrid.from_limits, thg=False) + ) + grid = constructor(LENGTH, 800e-9, (600e-9, 1.2e-6), 150e-15) + space = LineGrid(4e-4, 24) + pulse = SpatialPulse( + GaussianPulse(wavelength=800e-9, fwhm=30e-15, energy=1e-3), 80e-6, jones=(1,) + ) + responses = [ + KerrResponse(1e-25, thg=thg), + RamanResponse((DampedOscillator(1e-8, 2e14, undamped_dephasing()),), thg=thg), + ] + problem = make_problem( + grid, + space, + pulse.build(grid, space, medium=SpatialMedium()), + responses, + density=1.0, + ) + observed = {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + engine = select(name, problem, grid=grid) + cleanup.callback(engine.close) + engine.set_initial(problem.initial.field0, None, z=problem.initial.z) + engine.propagate_to(LENGTH) + observation = engine.observe(field=True) + observed[name] = (observation.field, observation.n_steps) + (field, steps), (expected, expected_steps) = ( + observed["julia"], + observed["numpy_ref"], + ) + assert steps == expected_steps + scale = float(np.linalg.norm(expected)) + assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale + + @binary64 def test_julia_tsit5_matches_the_reference(runtime): """An adaptive TSIT5 window takes the reference's steps and field.""" From 9d8149792d72a7423f17d68030ed8d202c4831ed Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 21:40:27 +0000 Subject: [PATCH 089/107] Julia: a GPU state copied to the host once a state [skip ci] A plane's observation, statistics, boundary monitor and transverse edge each asked for the state on the host, and each copy from a GPU waits for it (rdw on Metal: a sixth of the window in copy_state!). Every write of the state bumps engine.version; copy_state! keeps the last host copy and copies from the device only for a new version. A CPU reads its own array as before. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/SolpropJulia.jl | 6 ++++++ julia/src/dopri.jl | 1 + julia/src/free.jl | 4 ++-- julia/src/modal.jl | 4 ++-- julia/src/observe.jl | 13 ++++++++++++- julia/src/rk4.jl | 1 + 6 files changed, 24 insertions(+), 5 deletions(-) diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 1b9eda9e1..beb64998b 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -39,6 +39,10 @@ mutable struct Engine{C,W} # A tapered guide's scale at the stage, tau(z): the synthesis takes it, the # projection its reciprocal (`transform.taper_scale`); one without a taper. taper::Float64 + # Bumped by every write of the state, so that a GPU's host copy is made once a + # state (`copy_state!`): a plane's observation, statistics, monitor and edge each + # asked for it. + version::Int end include("launch.jl") @@ -197,6 +201,7 @@ function reset_work!(engine) foreach(buffer -> fill!(buffer, 0), buffers) engine.fsal_valid, engine.calls, engine.propagator_dz = false, 0, NaN engine.alarm, engine.alarm_ready = NaN, false + engine.version += 1 TIMING[] && empty!(TIMES) COUNT[] && empty!(COUNTS) nothing @@ -226,6 +231,7 @@ function compile!(engine) end function reset!(engine) + engine.version += 1 mask!(engine, engine.work.y) engine.fsal_valid = false engine.calls = 0 diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 8bdea00e8..7987a1a75 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -144,6 +144,7 @@ function commit_step!(engine, dz, monitored) engine.fsal_valid = true end pool_copy!(w.y, w.candidate, c) + engine.version += 1 c.embedded ? quadrature_alarm(engine) : NaN end diff --git a/julia/src/free.jl b/julia/src/free.jl index 3e6ce2797..8e7c19e0a 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -66,7 +66,7 @@ function create_free(c, host) pack = (input=pack_in, output=pack_out, forward=plan(c, plan_rfft, pack_in, 1)) end work = ( - adams=nothing, path=nothing, raman=raman_workspace(c, host, nt, chunk), monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), + adams=nothing, path=nothing, raman=raman_workspace(c, host, nt, chunk), monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), held_state=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), plasma=plasma, pack=pack, y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), @@ -83,7 +83,7 @@ function create_free(c, host) coarse_inverse=c.envelope ? plan(c, plan_bfft, coarse_spec, 1) : plan(c, plan_brfft, coarse_spec, nc, 1), coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), ) - Engine(c, work, false, 0, NaN, c.factor, NaN, false, 1.0) + Engine(c, work, false, 0, NaN, c.factor, NaN, false, 1.0, 0) end # For an exactly real squared longitudinal wave number the principal root is sqrt(x) diff --git a/julia/src/modal.jl b/julia/src/modal.jl index 6f1a0128b..f7b21a055 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -116,7 +116,7 @@ function create_modal(c, host) node_forward=spectral ? plan(c, plan_rfft, nodes, 1) : nothing, absorber_spec_band=dzeros(c, C, spectral && in_stage ? nw : 0, spectral && in_stage ? nm : 0), adams=adams_workspace(c, host, nw, nm), path=path_workspace(c, host), - monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), forward_stage=Ref{Any}(nothing), statistics=Ref{Any}(nothing), + monitor=monitor_workspace(c, nw, nm, c.nc), edge=Ref{Any}(nothing), held_state=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), forward_stage=Ref{Any}(nothing), statistics=Ref{Any}(nothing), raman=raman_workspace(c, host, nt, chunk; modes=nm, nodes=nn, synthesis=synthesis ./ nt), plasma=plasma, pack=pack, y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), fsal=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), @@ -132,7 +132,7 @@ function create_modal(c, host) coarse_inverse=c.envelope ? plan(c, plan_bfft, band, 1) : plan(c, plan_brfft, band, c.nc, 1), coarse_forward=c.envelope ? plan(c, plan_fft, coarse, 1) : plan(c, plan_rfft, coarse, 1), ) - Engine(c, work, false, 0, NaN, c.factor, NaN, false, 1.0) + Engine(c, work, false, 0, NaN, c.factor, NaN, false, 1.0, 0) end """The modes' analytic signals from their half spectrum `fine`: the one-sided spectrum diff --git a/julia/src/observe.jl b/julia/src/observe.jl index abf0ee848..840654b2b 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -28,7 +28,18 @@ function copy_between!(target, source, c) end function copy_state!(engine, buffer) @section :observe begin - target = copy_between!(host_wrap(buffer, ComplexF64), engine.work.y, engine.config) + c, w = engine.config, engine.work + target = host_wrap(buffer, ComplexF64) + if oncpu(c) + copy_between!(target, w.y, c) + else + # One copy from the device a state, however many readers ask (`version`). + held = w.held_state + if held[] === nothing || first(held[]) != engine.version + held[] = (engine.version, Matrix{ComplexF64}(Array(w.y))) + end + copyto!(target, last(held[])) + end scale = engine.config.scale scale == 1 || (target .*= scale) end diff --git a/julia/src/rk4.jl b/julia/src/rk4.jl index 9a9b79305..b238a2c09 100644 --- a/julia/src/rk4.jl +++ b/julia/src/rk4.jl @@ -14,6 +14,7 @@ function rk4!(engine, dz::Float64, key::Float64) c.free ? free_propagators!(engine, key / 2) : modal_flow!(engine, key / 2) none = zero(T) source!(engine, y) + engine.version += 1 each!(c, size(y)...) do f, m @inbounds begin flow = forward[f, m, 1] From 1d1abc75a1f59827a2d5312365f6cdbba9812498 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 21:44:24 +0000 Subject: [PATCH 090/107] Julia: the free-space operator's tables on every GPU [skip ci] On a GPU in binary64 too, each element's free-space rate and prefactor are formed once on the host and held as tables, as the double-float path holds them: each source re-formed the prefactor, a root and a division, at an A40's 1/64 binary64 rate (the Cartesian window's elementwise kernels were half its 379 ms of kernels against native's 90). A CPU keeps forming them where it reads them. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/free.jl | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/julia/src/free.jl b/julia/src/free.jl index 8e7c19e0a..22bd8c506 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -34,8 +34,10 @@ function create_free(c, host) # read. Where the wide type is a double-float, the elements are formed once on the # host in binary64 (the compensated subtraction and the root need it) and held as # a rate table in the wide type and a prefactor at the state's precision. - op = wide_eltype(c) === Float64 ? map(v -> v isa Array ? upload(c, v) : v, separable) : - free_tables(c, separable, nw, nm) + # On a GPU in binary64 too: each source re-formed every element's prefactor, a root + # and a division (binary64 at an A40's 1/64 rate, about half a Cartesian window). + op = wide_eltype(c) === Float64 && oncpu(c) ? + map(v -> v isa Array ? upload(c, v) : v, separable) : free_tables(c, separable, nw, nm) c = merge(c, ( spatial_shape=shape, op=op, field_scale=T(host.real("pad_scale")) * scale, absorber_scale=T(-0.5) * scale, spatial_rate=upload(c, T.(spatial_rate)), @@ -144,7 +146,7 @@ function free_propagators!(engine, h) # The zero-distance stage is exactly the identity. fill!(forward, 1) fill!(inverse, 1) - elseif wide_eltype(c) !== Float64 + elseif haskey(c.op, :rate) # The double-float exponent's pair shares one reduced phasor (wide_exp_pair). # (Names of their own: a captured name assigned in two branches is boxed.) rates, pair, length = c.op.rate, !c.low_storage, wide_value(c, Float64(h)) From a03f1d8cb3a651e5834762a15ab0e866f146bcba Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 22:03:54 +0000 Subject: [PATCH 091/107] Julia: several plasma channels [skip ci] A mixture's ionising species each take their own rate table and constants (the adapter packs them, the first unsuffixed); the engine runs the current and population passes once a channel, the later ones adding their currents, and returns each species' populations (a row a channel) for the shared statistics. Each later channel's density and preionisation are stage rows after the taper. One channel runs exactly as before. Air's two channels on a capillary match numpy_ref: the field within 1e-10, every species statistic within 1e-9. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/free.jl | 6 ++- julia/src/modal.jl | 6 ++- julia/src/responses.jl | 68 ++++++++++++++++++++------ julia/src/stages.jl | 14 +++++- src/solprop/backends/julia/_backend.py | 28 ++++++----- tests/backends/test_julia.py | 59 ++++++++++++++++++++++ 6 files changed, 149 insertions(+), 32 deletions(-) diff --git a/julia/src/free.jl b/julia/src/free.jl index 22bd8c506..1daa18ae9 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -325,7 +325,9 @@ function population_free_snapshot(engine, input) each!(c, size(modal)...) do t, m @inbounds projected[t, m] = scale * modal[t, m] end - maxima .= max.(maxima, population_parts!(p, projected, c, first, count)) + each_channel(p) do q, _ + maxima .= max.(maxima, population_parts!(q, projected, c, first, count)) + end end - (Vector{Float64}(Array(p.fractions)), Vector{Float64}(Array(p.peaks)), maxima) + (channel_rows(p.fractions_all), channel_rows(p.peaks_all), maxima) end diff --git a/julia/src/modal.jl b/julia/src/modal.jl index f7b21a055..dcd026a70 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -423,7 +423,9 @@ function population_snapshot(engine, input) last = min(first + chunk - 1, nn) count = last - first + 1 gemm!(@view(w.nodes[:, 1:count]), w.modal, @view(c.synthesis[:, first:last]), engine.taper, false, c) - maxima .= max.(maxima, population_parts!(p, w.nodes, c, first, count)) + each_channel(p) do q, _ + maxima .= max.(maxima, population_parts!(q, w.nodes, c, first, count)) + end end - (Vector{Float64}(Array(p.fractions)), Vector{Float64}(Array(p.peaks)), maxima) + (channel_rows(p.fractions_all), channel_rows(p.peaks_all), maxima) end diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 4b6998301..240afd658 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -83,11 +83,19 @@ function plasma_workspace(c, host, nt, chunk, nm, nn) # the spectral modal path), the modes' where they are projected first. by_node = c.free || (haskey(c, :spectral) && c.spectral) columns = by_node ? 0 : nm + # Several channels (a mixture's species): each its rate table and constants, the + # first's also as the workspace's own fields, so that one channel runs as before. + count = host.has("plasma_count") ? host.int("plasma_count") : 1 + suffix(k) = k == 1 ? "" : "_$k" + channels = [(coefficients=upload(c, host.array("plasma_coefficients" * suffix(k), T)), + parameters=host.array("plasma_parameters" * suffix(k), Float64)) for k in 1:count] + fractions_all, peaks_all = dzeros(c, T, nn, count), dzeros(c, T, nn, count) ( - coefficients=upload(c, host.array("plasma_coefficients", T)), + channels=channels, fractions_all=fractions_all, peaks_all=peaks_all, + coefficients=channels[1].coefficients, # Field range, rate cap, log-table origin and step, charge-mass ratio and # ionisation potential; density and preionisation are a stage's (stages.jl). - parameters=host.array("plasma_parameters", Float64), + parameters=channels[1].parameters, taps=upload(c, host.array("plasma_taps", T)), floor=host.flag("plasma_floor"), dt=T(host.real("dt")), field_scale=T(c.scale), inverse_omega=upload(c, T.(inv.(host.array("omega", Float64)))), @@ -103,7 +111,8 @@ function plasma_workspace(c, host, nt, chunk, nm, nn) coarse=dzeros(c, T, nt, columns), coarse_edge=dzeros(c, T, nt, columns), spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, by_node ? chunk : nm), edge_spectrum=dzeros(c, Complex{T}, nt ÷ 2 + 1, by_node ? chunk : nm), - fractions=dzeros(c, T, nn), peaks=dzeros(c, T, nn), parts=dzeros(c, T, 6, chunk), + fractions=view(fractions_all, :, 1), peaks=view(peaks_all, :, 1), + parts=dzeros(c, T, 6, chunk), ) end @@ -174,7 +183,7 @@ end """The gated and edge currents of a column: the free current plus the loss current, formed everywhere and kept where the rate and the field are live.""" @noinline function currents_column!(gated, edge, nodes, rate, fraction, current, window, - derivative, node, potential, density) + derivative, node, potential, density, add=false) none = zero(potential) @inbounds @simd for t in axes(nodes, 1) field, value = nodes[t, node], rate[t, node] @@ -182,8 +191,13 @@ formed everywhere and kept where the rate and the field are live.""" loss = ifelse((value > 0) & (squared > 0), (potential * value * (1 - fraction[t, node]) / squared) * field, none) total = density * (current[t, node] + loss) - gated[t, node] = window[t] * total - edge[t, node] = derivative[t] * total + if add + gated[t, node] += window[t] * total + edge[t, node] += derivative[t] * total + else + gated[t, node] = window[t] * total + edge[t, node] = derivative[t] * total + end end end """The rate inside the table's span, `lower <= x < upper` (or NaN).""" @@ -327,9 +341,27 @@ pass is a sample a thread and the two running integrals are column-wise scans: t sums are reassociated, which SEP 25 permits and the tests bound, as native's two-level device scans do. """ -plasma_current!(p, nodes, c, count) = - oncpu(c) && !SAMPLE_PLASMA[] ? plasma_columns!(p, nodes, c, count) : - plasma_samples!(p, nodes, c, count) +plasma_current!(p, nodes, c, count) = each_channel(p) do q, add + oncpu(c) && !SAMPLE_PLASMA[] ? plasma_columns!(q, nodes, c, count, add) : + plasma_samples!(q, nodes, c, count, add) +end + +"""Call `f(q, add)` for each plasma channel: `q` the workspace with the channel's rate +table, constants and population tables in place of the first's, `add` whether its +currents add to those the channels before it formed.""" +function each_channel(f::F, p) where {F} + for (k, channel) in enumerate(p.channels) + q = k == 1 ? p : + merge(p, (coefficients=channel.coefficients, parameters=channel.parameters, + fractions=view(p.fractions_all, :, k), peaks=view(p.peaks_all, :, k))) + f(q, k > 1) + end +end + +"""The channels' population tables for the host: a vector for one channel, a +(channel, node) matrix for several.""" +channel_rows(a) = size(a, 2) == 1 ? Vector{Float64}(Array(a)[:, 1]) : + Matrix{Float64}(permutedims(Array(a))) # SOLPROP_JULIA_PLASMA=samples takes the GPU's path on a CPU too. const SAMPLE_PLASMA = Ref(false) @@ -348,7 +380,7 @@ function integrate_samples!(out, values, taps, dt, c, count) nothing end -function plasma_samples!(p, nodes, c, count) +function plasma_samples!(p, nodes, c, count, add=false) T = typeof(p.dt) (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative) = p window, floor = c.window, p.floor @@ -376,13 +408,18 @@ function plasma_samples!(p, nodes, c, count) loss = rate[t, n] > 0 && squared > 0 ? (potential * rate[t, n] * (1 - fraction[t, n]) / squared) * field : none total = density * (current[t, n] + loss) - gated[t, n] = window[t] * total - edge[t, n] = derivative[t] * total + if add + gated[t, n] += window[t] * total + edge[t, n] += derivative[t] * total + else + gated[t, n] = window[t] * total + edge[t, n] = derivative[t] * total + end end end end -function plasma_columns!(p, nodes, c, count) +function plasma_columns!(p, nodes, c, count, add=false) T = typeof(p.dt) (; rate, fraction, integrand, current, gated, edge, taps, dt, derivative, live, scratch, knots) = p window, floor = c.window, p.floor @@ -395,7 +432,8 @@ function plasma_columns!(p, nodes, c, count) peak = exposure_column!(rate, fraction, nodes, node, taps, dt, args, live, scratch, knots) # With exactly zero rates and no initial electrons both currents vanish. if iszero(peak) && iszero(initial) - @inbounds for t in 1:nt + # (A later channel adds nothing.) + add || @inbounds for t in 1:nt gated[t, node] = 0 edge[t, node] = 0 end @@ -404,7 +442,7 @@ function plasma_columns!(p, nodes, c, count) fraction_column!(fraction, integrand, nodes, node, initial, charge, floor) integrate_column!(current, integrand, node, taps, dt) currents_column!(gated, edge, nodes, rate, fraction, current, window, derivative, - node, potential, density) + node, potential, density, add) nothing end end diff --git a/julia/src/stages.jl b/julia/src/stages.jl index f1efe33dc..53feadbf7 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -14,7 +14,11 @@ function path_workspace(c, host) (phi=upload(c, phi), prefactor=upload(c, pre), delta=zeros(size(phi, 3), stages), weights=zeros(size(pre, 3), stages), delta_device=dzeros(c, wide_eltype(c), size(phi, 3), stages), - weights_device=dzeros(c, c.T, size(pre, 3), stages), material=[zeros(3, stages); ones(1, stages)], + weights_device=dzeros(c, c.T, size(pre, 3), stages), + # Kerr, the first channel's density and preionisation, the taper, then each later + # channel's density and preionisation. + material=[zeros(3, stages); ones(1, stages); + zeros(2 * ((host.has("plasma_count") ? host.int("plasma_count") : 1) - 1), stages)], tables=Dict{String,Any}(), constants=zeros(4)) end @@ -49,6 +53,10 @@ function material_stage!(engine, stage) if w.plasma !== nothing w.plasma.parameters[8] = p.material[2, stage] w.plasma.parameters[9] = p.material[3, stage] + for k in 2:length(w.plasma.channels) + parameters = w.plasma.channels[k].parameters + parameters[8], parameters[9] = p.material[3+2(k-1), stage], p.material[4+2(k-1), stage] + end end end @@ -124,8 +132,10 @@ function configure_stages_at!(engine, z0, positions) column(name) = haskey(tables, name) ? stage_values(tables[name], zs)[:, 1] : zeros(n) density = column("kerr") taper = haskey(tables, "taper") ? stage_values(tables["taper"], zs)[:, 1] : ones(n) + later = [column(name * "_$k") for k in 2:(size(path.material, 1) - 2) ÷ 2 + for name in ("plasma", "preionisation")] material = permutedims(hcat([kerr * d * scale2 for d in density], - column("plasma"), column("preionisation"), taper)) + column("plasma"), column("preionisation"), taper, later...)) configure_stages!(engine, delta, weights, material) end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index f80f7f27e..048351a1d 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -185,7 +185,6 @@ def _refuse(problem: KernelProblem) -> None: "planar transforms": transform.geometry is not None and transform.geometry.kind not in {"radial", "free"}, "nonseparable longitudinal tables": not terms(problem).device_ready, - "multiple plasma channels": len(response.plasma_channels) > 1, # Several components sum into one kernel (each term weighted by its density # and fraction); they must agree on the third harmonic. "Raman components that disagree on the third harmonic": len( @@ -414,11 +413,13 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: ) if responses.plasma_channels: - channel = responses.plasma_channels[0] - table = channel.rate - config.update( - plasma_coefficients=table.coefficients.copy(), - plasma_parameters=np.array( + # Each channel's rate table and constants; the first unsuffixed, later ones _k. + config["plasma_count"] = len(responses.plasma_channels) + for k, channel in enumerate(responses.plasma_channels, start=1): + suffix = "" if k == 1 else f"_{k}" + table = channel.rate + config[f"plasma_coefficients{suffix}"] = table.coefficients.copy() + config[f"plasma_parameters{suffix}"] = np.array( [ table.field_min, table.field_max, @@ -430,7 +431,8 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: float(channel.density(0.0)), float(channel.preionisation(0.0)), ] - ), + ) + config.update( plasma_taps=responses.plasma_integral.taps.copy(), plasma_floor=responses.plasma_integral.policy == "band", dt=grids.dt_fine, @@ -819,9 +821,10 @@ def _bind_stage_tables(self) -> None: kerr = responses.kerr_coefficients if kerr is not None: tables["kerr"] = responses.density if kerr.density is None else kerr.density - for channel in responses.population_channels[:1]: - tables["plasma"] = channel.density - tables["preionisation"] = channel.preionisation + for k, channel in enumerate(responses.population_channels, start=1): + suffix = "" if k == 1 else f"_{k}" + tables[f"plasma{suffix}"] = channel.density + tables[f"preionisation{suffix}"] = channel.preionisation if problem.transform.taper_scale is not None: # A tapered guide's scale: the synthesis takes it, the projection its # reciprocal. @@ -1349,7 +1352,10 @@ def _populations(self, spec: StatsSpec, state: np.ndarray) -> dict[str, np.ndarr # The engine reads the state it holds, which is the one observed. del state raw = call_julia(self._jl.population_snapshot, self._engine, None) - fractions, peaks = (np.asarray(raw[i], dtype=float)[None] for i in (0, 1)) + # A row a channel. + fractions, peaks = ( + np.atleast_2d(np.asarray(raw[i], dtype=float)) for i in (0, 1) + ) parts = np.asarray(raw[2], dtype=float) else: fractions = peaks = np.zeros((0, self._problem.transform.n_nodes)) diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index e9030288b..324616c2c 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -478,6 +478,65 @@ def test_julia_free_space_raman_matches_the_reference(runtime, grid_kind, thg): assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@binary64 +def test_julia_two_plasma_channels_match_the_reference(runtime): + """Air's two ionising species: each channel's rates and currents, summed, and each + species' populations, as the reference forms them.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length, observed = 0.004, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = Simulation.from_capillary( + 50e-6, + length, + {"N2": 0.79, "O2": 0.21}, + 1.0, + wavelength=800e-9, + wavelength_limits=(200e-9, 3e-6), + trange=300e-15, + fwhm=10e-15, + energy=60e-6, + n_save=2, + backend=name, + integrator=RungeKutta(), + schedule=FixedSchedule.uniform(0.0, length, length / 16), + absorber_scheme="split_step", + noise=None, + raman=False, + ) + problem = simulation.translate() + assert len(problem.responses.plasma_channels) == 2 + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + observed[name] = ( + engine.observe(field=True).field, + engine.stats(problem.stats_spec), + ) + (field, statistics), (expected, reference) = ( + observed["julia"], + observed["numpy_ref"], + ) + scale = float(np.linalg.norm(expected)) + assert float(np.linalg.norm(field - expected)) <= 1e-10 * scale + for statistic, value in reference.items(): + if statistic in ROUNDING_ESTIMATES or statistic not in statistics: + continue + largest = float(np.max(np.abs(value), initial=0.0)) + np.testing.assert_allclose( + statistics[statistic], + value, + rtol=1e-9, + atol=1e-9 * largest, + err_msg=statistic, + ) + + @binary64 def test_julia_tsit5_matches_the_reference(runtime): """An adaptive TSIT5 window takes the reference's steps and field.""" From f262af8780b2cf655ebb30708487937cb77cdc66 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 22:05:12 +0000 Subject: [PATCH 092/107] Julia: STATUS brought up to date (Metal tuning, eleven features, A40 leads) [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/STATUS.md | 92 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 65 insertions(+), 27 deletions(-) diff --git a/julia/STATUS.md b/julia/STATUS.md index 02dddaed8..cefa8bc85 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -203,40 +203,78 @@ The cheapest step with the most information is to replace `mlx` first: profile M on the losing cases, add `mlx`'s features, run SEP 33's qualification on `df32`, and compare again. +## The evening's work (2026-11-07) + +**Metal against `mlx`: 0.66** (1.25 in the morning), Julia faster in six of seven +cases. The changes, each A/B'd on Metal (the ledger has the rows): +- A chunk's constant projection rows kept contiguous (`table_rows`). +- Device copies as one kernel, views included (`device_copy!`): Metal.jl's `copyto!` + into a view cost about 200 us. +- One value the host waits for a step (`sum_device!`, the alarm read with the norms). +- One chunk of nodes a source on a GPU (`node_chunk`). +- The trial's tables in one upload (`device_tables`). +- The population statistics in one parallel reduction and one readback. +- A source's forward streams packed into one transform (modal and free space). +- A GPU state copied to the host once a state (`engine.version`, `copy_state!`). +- The free-space operator's tables on every GPU (binary64 too). +- The analytic signal from the spectrum (as native forms it; no benchmark case uses + it). + +**`mlx`'s features: 11 of 13 closed**, each tested against `numpy_ref` (binary64, +fields within 1e-10, most about 1e-15): lockstep batches, TSIT5, modal RK4IP, +several Raman components, tapers, the window statistics and `zdw`, resolved and radial +envelopes, the envelope's third harmonic, Raman in free space, several plasma channels. + ## Next steps -Measured or diagnosed, not yet done, roughly in order of what they would tell. - -1. **Metal's waits.** Fuse the per-step reductions the host reads (the trial's norms, - the quadrature alarm, the monitor) into fewer readbacks, about 0.2 ms each on the - M5 Max. Profile with `SOLPROP_JULIA_TIMING=1 SOLPROP_JULIA_DEVICE=metal python - julia/profile.py PLAN.json ROW` (a plan's rows need `"backend": "native"` to be - picked). -2. **`mlx`'s coverage on Metal.** Envelope plasma, tapers, batches, several plasma - channels and Raman terms; then SEP 33's drift and envelope qualification of the - double-float path. With 1, enough to decide whether Julia can replace `mlx`. -3. **Metal start latency.** Record the device's specialisations into a trace as - `src/precompile_trace.jl` was, or try a PackageCompiler system image. -4. **Binary32 on x86.** Two to three times binary64 on the Xeon, and not subnormals. - Profile one thread, `rdw`, binary32 against binary64 section by section. -5. **The GPU host on CUDA and ROCm.** CUDA graphs or fused trials (launches about 75 a - trial); re-measure an H200 or MI325X afterwards, not before. -6. **Native.** #333 (default budget on Apple silicon: the top-tier cores) and #560's - ideas, which these measurements feed. +Roughly in order of what they would tell. + +1. **The remaining `mlx` features.** Varying Raman (each term's decay rate and each + component's density as stage tables; the kernel rebuilt on the device when the + rates change, with a fixed block exponent in binary32), Cartesian Adams (the phi + moments from the free-space rate table, which every GPU now holds), envelope plasma + (a port of `mlx_gpu/envelope.py`), the on-axis plasma statistics (the populations on + an on-axis node). Vector polarisation and tensor Raman are deferred. +2. **`line` on Metal (1.5 against `mlx`).** About a third of its window is the + statistics: `spatial_local!` and the population snapshot read back several arrays + a plane. Fold them into one readback; fuse `source_free!`'s elementwise passes. +3. **The A40 against native (about 1.9 binary64, 1.5 binary32 df32).** Fair profiles + need `nsys --cuda-graph-trace=node` (native's sources run in CUDA graphs). What is + left: + - Host time between launches (the march and the trial tables while the device + idles), about twice native's. Kernel launches are cheap (2.5 us), cuFFT 3 us, + cuBLAS 14 us, a readback 31 us (DMOG A40, `scripts/launch_cost.jl`). + - The Adams predictor kernel, 0.28 ms a step on `rdw`: its phi functions spill to + local memory (120 to 230 bytes; `scripts/phi_regs.jl`). + - Cartesian transforms: a 2D FFT over the trailing dimensions of the frequency-first + state is 3.4 times one over contiguous leading dimensions (16.2 against 4.8 ms at + 512 x 192 x 192). A transverse-first layout for free space is the fix. + - radial's CUTLASS binary64 GEMMs (the A40 has no binary64 tensor cores). + - CUDA graph capture would need the kernels to read their changing scalars from + device memory, as native's do. +4. **Metal start latency** (about 28 s of kernel compilation): a recorded trace or a + system image. +5. **Binary32 on x86**, two to three times binary64 on the Xeon, not subnormals. +6. **Pro GPUs** (H200, MI325X; DigitalOcean, a US$30 cap approved), after 3. The working setups: on the Mac a worktree with native built on the NEON FFTW prefix -(`~/buildtools/fftw-3.3.11-neon`) and `uv sync --extra julia --extra mlx`; on DMOG -`/mnt/data/shared/jt52/solprop-julia-20261106` (`jl13-a40.sbatch` reuses a native CUDA -wheel and runs the tests and two A/Bs); on the Xeon -`~/awork/solprop-julia-ftz-20261107` (a venv without native, for Julia-only A/Bs). -The raw data are in the private `solprop-dev/benchmarks/julia-m5-2026-11-07`. +(`~/buildtools/fftw-3.3.11-neon`) and `uv sync --extra julia --extra mlx`; an A/B of +two Julia trees runs the baseline through a wrapper interpreter that sets +`SOLPROP_JULIA_ROOT` (never edit a tree a benchmark is loading). On DMOG +`/mnt/data/shared/jt52/solprop-julia-20261106`: `jl17-a40.sbatch` (a tree from `git +archive`, jl12's native CUDA wheel, the tests, the previous tree against this one, and +native against both precisions), `jl15-nsys*.sbatch` (Nsight profiles through +`scripts/prof_case.py`). On the Xeon `~/awork/solprop-julia-ftz-20261107`. The raw data +are in the private `solprop-dev/benchmarks/julia-m5-2026-11-07` and +`julia-gpu-2026-11`. ## Not run -Vector polarisation, batches, noise, envelope plasma, several plasma channels or Raman -terms, varying Raman, dispersive Kerr, TDSE, planar and general modal guides, tapers, -coupled flows, the interaction Adams formulation, the carrier frame and interpolated -planes are refused by name; so is binary64 on Metal. +Vector polarisation and tensor Raman, noise, envelope plasma, varying Raman +coefficients, dispersive Kerr, TDSE, planar and general modal guides, coupled flows, the +interaction Adams formulation, Adams on free space, the carrier frame, interpolated +planes, low-storage integration with a varying operator, tableaux other than DOPRI5 and +TSIT5, and the on-axis plasma statistics are refused by name; so is binary64 on Metal. ## Findings for main From 137c691562be67d6c8e7dfe3bedad851ea0e0915 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sat, 7 Nov 2026 23:12:10 +0000 Subject: [PATCH 093/107] Julia: the fused Kerr pass back in free space without plasma or Raman [skip ci] The free-space Raman restructure formed the scaled field and then the polarisation in two passes; on a Cartesian state that extra pass made the 192 x 192 window 25 % slower on an A40 (binary64). Without plasma or Raman the field and its polarisation are one pass again, as before. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/free.jl | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/julia/src/free.jl b/julia/src/free.jl index 1daa18ae9..cc9295fb1 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -174,6 +174,29 @@ function free_propagators!(engine, h) 1 end +"""The Kerr polarisation of the scaled field in one pass: the envelope's, with its +third-harmonic term where one is compiled, or the field grid's.""" +function fused_kerr!(projected, modal, c, scale, factor, a, window) + if c.envelope + h, carrier = factor * c.harmonic, c.carrier + harmonic = !iszero(h) + each!(c, size(modal)...) do t, m + @inbounds begin + v = scale * modal[t, m] + response = factor * a * abs2(v) * v + if harmonic + response += h * carrier[t] * (v * v) * v + end + projected[t, m] = response * window[t] + end + end + else + each!(c, size(modal)...) do t, m + @inbounds projected[t, m] = polarization(scale * modal[t, m], factor, a) * window[t] + end + end +end + transverse!(a, plan, c) = (plan * reshape(a, size(a, 1), c.spatial_shape...); nothing) """Copy columns `first:first+count-1` of `physical` into the fine spectrum.""" @@ -203,13 +226,18 @@ function source_free!(engine, lab) count = min(chunk, nm - first + 1) scatter_columns!(fine, physical, first, count, c) mul!(modal, w.inverse_plan, fine) + raman = w.raman + if w.plasma === nothing && raman === nothing && !c.analytic + # Kerr alone: the field and its polarisation in one pass, as a Cartesian + # state is large (two passes made a 192 x 192 window a quarter slower). + fused_kerr!(projected, modal, c, scale, factor, a, window) + else # The physical field, which the plasma reads, then the responses in place, as # a modal source's nodes take them (`node_response!`). each!(c, size(modal)...) do t, m @inbounds projected[t, m] = scale * modal[t, m] end w.plasma === nothing || plasma_current!(w.plasma, projected, c, count) - raman = w.raman if c.envelope raman === nothing || raman_drive!(raman, projected, projected, c, chunk) nonlinear_envelope!(projected, c, factor, raman, chunk) @@ -221,6 +249,7 @@ function source_free!(engine, lab) raman === nothing || raman_drive!(raman, projected, projected, c, chunk) nonlinear_nodes!(projected, projected, c, factor, raman, chunk) end + end # The held-current polarisation joins before the transverse forward transform, # as the reference Cartesian source does. if w.pack !== nothing From a23cfd3fcf54d4388d04bbcf17d9fb36d7aa6319 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 00:03:43 +0000 Subject: [PATCH 094/107] Julia experiment: varying Raman, Cartesian Adams, envelope plasma [skip ci] Varying Raman: each term's decay rate and each component's density as stage tables; the kernel rebuilt when they change. Cartesian Adams: the free-space rate table as the Adams operator. Envelope plasma: the cycle-averaged rate by the oracle's angular quadrature (mlx's precise rate for binary32's refinement), the drive and loss streams through the shared plasma path. Each tested against numpy_ref (binary64 1e-10; binary32 1e-4 in both wide types) on DMOG CPU. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/SolpropJulia.jl | 1 + julia/src/envelope.jl | 237 +++++++++++++++++++++++++ julia/src/free.jl | 9 +- julia/src/responses.jl | 60 ++++++- julia/src/stages.jl | 17 +- src/solprop/backends/julia/_backend.py | 91 ++++++++-- tests/backends/test_julia.py | 122 ++++++++++++- 7 files changed, 518 insertions(+), 19 deletions(-) create mode 100644 julia/src/envelope.jl diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index beb64998b..5717688f7 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -49,6 +49,7 @@ include("launch.jl") include("dfloat.jl") include("vmath.jl") include("responses.jl") +include("envelope.jl") include("modal.jl") include("free.jl") include("dopri.jl") diff --git a/julia/src/envelope.jl b/julia/src/envelope.jl new file mode 100644 index 000000000..0831ed0de --- /dev/null +++ b/julia/src/envelope.jl @@ -0,0 +1,237 @@ +# SPDX-FileCopyrightText: 2026 John C. Travers and contributors +# SPDX-License-Identifier: GPL-3.0-or-later + +# The envelope grid's plasma (translate/envelope_plasma.py; the oracle is +# numpy_ref/envelope_plasma.py). Each channel's cycle-averaged rate comes from the +# instantaneous table by angular quadrature over the field's polarisation ellipse; +# the population is the running trapezoid of that rate; two currents follow, the +# Drude drive and the loss, each windowed, projected and transformed as the field +# grid's two plasma streams are, and joined with -1/omega^2 and -i/omega. +# +# A scalar envelope's ellipse is a line: its major axis |E| and its minor/major ratio +# zero, so the cosine moment Mc is the rate and the loss current is 2 Mc E / |E|^2. + +"""The envelope plasma's workspace: the field plasma's fields where the shared paths +read them (the channels, the population tables, the projected and transformed +streams), complex, and the cycle quadrature's rules and spectral factors.""" +function envelope_plasma_workspace(c, host, nt, chunk, nm, nn) + host.flag("envelope_plasma") || return nothing + T, C = c.T, Complex{c.T} + by_node = c.free + columns = by_node ? 0 : nm + count = host.int("plasma_count") + suffix(k) = k == 1 ? "" : "_$k" + channels = [precise_table(c, host.array("plasma_coefficients" * suffix(k), Float64), + host.array("plasma_parameters" * suffix(k), Float64)) for k in 1:count] + fractions_all, peaks_all = dzeros(c, T, nn, count), dzeros(c, T, nn, count) + # The rules of orders 64, 128, 256 and 512 end to end; `levels` each one's end. + nodes, weights = host.array("envelope_rule_nodes", Float64), host.array("envelope_rule_weights", Float64) + ends = Tuple(cumsum(Int.(host.array("envelope_rule_orders", Int)))) + nf = c.nf + ( + envelope=Val(true), channels=channels, fractions_all=fractions_all, peaks_all=peaks_all, + coefficients=channels[1].coefficients, parameters=channels[1].parameters, + constant_tail=channels[1].constant_tail, inverse_edges=channels[1].inverse_edges, + inverse_tail=channels[1].inverse_tail, + dt=T(host.real("dt")), field_scale=T(c.scale), + rule_nodes=upload(c, T.(nodes)), rule_weights=upload(c, T.(weights)), levels=ends, + drude=upload(c, T.(host.array("envelope_drude", Float64))), + loss_factor=upload(c, C.(host.array("envelope_loss", ComplexF64))), + rate=dzeros(c, T, nt, chunk), exposure=dzeros(c, T, nt, chunk), + gated=dzeros(c, C, nt, chunk), edge=dzeros(c, C, nt, chunk), + projected=dzeros(c, C, nt, columns), edge_projected=dzeros(c, C, nt, columns), + coarse=dzeros(c, C, nt, columns), coarse_edge=dzeros(c, C, nt, columns), + spectrum=dzeros(c, C, nf, by_node ? chunk : nm), + edge_spectrum=dzeros(c, C, nf, by_node ? chunk : nm), + fractions=view(fractions_all, :, 1), peaks=view(peaks_all, :, 1), + ) +end + +"""A channel's table for `precise_rate`: the cubic at the state's precision, with its +constant term's tail, and each interval's inverse left edge as a head and a tail (the +mlx backend's DeviceRateTable).""" +function precise_table(c, coefficients, parameters) + T = c.T + n = size(coefficients, 2) + edges = exp.(parameters[4] .+ (0:n-1) .* parameters[5]) + inverse = inv.(edges) + (coefficients=upload(c, T.(coefficients)), parameters=parameters, + constant_tail=upload(c, T.(coefficients[4, :] .- Float64.(T.(coefficients[4, :])))), + inverse_edges=upload(c, T.(inverse)), inverse_tail=upload(c, T.(inverse .- Float64.(T.(inverse))))) +end + +"""The rate at a field inside the table's span, accurate to the state's precision: the +local coordinate `log1p(E / E_i - 1)` against the interval's left edge (a binary32 +`log E` would carry `|log E| u`, which the rate's slope multiplies), and the constant +term added by an exact two-sum and its tail, the rate `exp(hi) (1 + lo)` (the mlx +backend's `rate_at`). The cycle quadrature's refinement needs it: two rules agree to +2e-6, which a binary32 rate formed through `log E` misses by an order.""" +@inline function precise_rate(e, table, tail, inverse, inverse_tail, cap, origin, step) + k = clamp(unsafe_trunc(Int, floor((log(e) - origin) / step)) + 1, 1, size(table, 2)) + @inbounds begin + p = e * inverse[k] + error = fma(e, inverse[k], -p) + e * inverse_tail[k] + x = (p - 1) + error + u = 1 + x + coordinate = u == 1 ? x : log(u) * x / (u - 1) + constant = table[4, k] + remainder = ((table[1, k] * coordinate + table[2, k]) * coordinate + table[3, k]) * coordinate + head = constant + remainder + shifted = head - constant + low = (constant - (head - shifted)) + (remainder - shifted) + tail[k] + min(exp(head) * (1 + low), cap) + end +end + +is_envelope(p) = false +is_envelope(p::NamedTuple) = haskey(p, :envelope) + +"""One panel's two directional moments, `(upper - lower)/pi` times the rule's sums of +`W(major sqrt(d)) / d` against cos^2 and sin^2, `d = cos^2 + ratio^2 sin^2` (zero +ratio here). A panel's kind replaces the table's cutoffs: before the high cut the +ceiling rate, between the cuts the field held inside the table's span (binary32's +rounding of a cut angle cannot put a node across a cutoff). The sums are compensated.""" +@inline function panel_moments(major, lower, upper, ceiling, args, nodes, weights, first, last) + T = typeof(major) + half = (upper - lower) / 2 + s0, e0, s1, e1 = zero(T), zero(T), zero(T), zero(T) + table, tail, inverse, inverse_tail, low, high, cap, origin, step = args + @inbounds for i in first:last + theta = muladd(nodes[i] + 1, half, lower) + sine, cosine = sincos(theta) + c2, s2 = cosine * cosine, sine * sine + rate = ceiling ? cap : + precise_rate(clamp(major * sqrt(c2), low, high), table, tail, inverse, inverse_tail, cap, origin, step) + r = rate / c2 + a, b = weights[i] * r * c2, weights[i] * r * s2 + # Neumaier's compensated sums. + t0 = s0 + a + e0 += abs(s0) >= abs(a) ? (s0 - t0) + a : (a - t0) + s0 + s0 = t0 + t1 = s1 + b + e1 += abs(s1) >= abs(b) ? (s1 - t1) + b : (b - t1) + s1 + s1 = t1 + end + width = (upper - lower) / T(pi) + (width * (s0 + e0), width * (s1 + e1)) +end + +"""The rule of `level`'s moments: split at the angles where `major cos(theta)` crosses +the table's cutoffs; the panel past the low cut contributes nothing.""" +@inline function rule_moments(major, args, nodes, weights, first, last) + T = typeof(major) + low, high = args[5], args[6] + quarter = T(pi) / 2 + # Past the low cut's angle the field is below the table: zero. + cut_low = low / major < 1 ? acos(low / major) : quarter + cut_high = high / major < 1 ? acos(high / major) : zero(T) + a0, a1 = panel_moments(major, zero(T), cut_high, true, args, nodes, weights, first, last) + b0, b1 = panel_moments(major, cut_high, cut_low, false, args, nodes, weights, first, last) + (a0 + b0, a1 + b1) +end + +"""The cosine moment of a scalar envelope of physical amplitude `major`, refined until +two successive rules agree within 2e-6 (floor 1e-30 s^-1); NaN where the 512-point rule +does not converge (the oracle's ConvergenceError: the step's norm refuses it).""" +@inline function cycle_rate(major, args, nodes, weights, levels) + T = typeof(major) + low = args[5] + major < low && return zero(T) + budget, floor = T(2e-6), T(1e-30) + previous = rule_moments(major, args, nodes, weights, 1, levels[1]) + for k in 2:length(levels) + current = rule_moments(major, args, nodes, weights, levels[k-1] + 1, levels[k]) + if all(isfinite, current) && + abs(current[1] - previous[1]) <= budget * max(current[1], floor) && + abs(current[2] - previous[2]) <= budget * max(current[2], floor) + return current[1] + end + previous = current + end + T(NaN) +end + +"""The chunk's cycle-averaged rates and their running trapezoid, per channel.""" +function envelope_exposure!(q, nodes, c, count) + (; rate, exposure, dt, rule_nodes, rule_weights, levels) = q + T = typeof(dt) + args = (q.coefficients, q.constant_tail, q.inverse_edges, q.inverse_tail, + ntuple(k -> T(q.parameters[k]), 5)...) + scale = q.field_scale + nt = size(nodes, 1) + each!(c, nt, count) do t, n + @inbounds rate[t, n] = cycle_rate(scale * abs(nodes[t, n]), args, rule_nodes, rule_weights, levels) + end + half, none = dt / 2, zero(dt) + each!(c, nt, count) do t, n + @inbounds exposure[t, n] = t == 1 ? none : muladd(half, rate[t-1, n], half * rate[t, n]) + end + tally!(:scan) + AK.accumulate!(+, @view(exposure[:, 1:count]); dims=1, init=none, backend=c.backend) + nothing +end + +"""The chunk's windowed drive and loss currents, every channel's summed.""" +function envelope_current!(p, nodes, c, count) + window = c.window + each_channel(p) do q, add + envelope_exposure!(q, nodes, c, count) + (; rate, exposure, gated, edge) = q + T = typeof(q.dt) + charge, potential = T(q.parameters[6]), T(q.parameters[7]) + density, initial = T(q.parameters[8]), T(q.parameters[9]) + none = zero(eltype(gated)) + each!(c, size(nodes, 1), count) do t, n + @inbounds begin + v, e = nodes[t, n], exposure[t, n] + survival = (1 - initial) * exp(-e) + fraction = initial + (1 - initial) * -expm1(-e) + squared = abs2(v) + drive = (charge * density * fraction) * v + loss = squared > 0 ? (potential * density * survival) * (2 * rate[t, n] / squared) * v : none + if add + gated[t, n] += window[t] * drive + edge[t, n] += window[t] * loss + else + gated[t, n] = window[t] * drive + edge[t, n] = window[t] * loss + end + end + end + end + nothing +end + +"""Add the drive's and the loss's spectra times -1/omega^2 and -i/omega (zero off the +supported band).""" +function add_envelope_spectra!(destination, p, c; coarse=false) + spectrum, edge_spectrum = p.spectrum, p.edge_spectrum + drude, loss, crop = p.drude, p.loss_factor, c.crop + each!(c, length(crop), size(destination, 2)) do f, m + @inbounds begin + k = crop[f] + destination[k, m] += drude[f] * spectrum[k, m] + loss[f] * edge_spectrum[k, m] + end + end +end + +"""Fresh populations at an observation: each node's final fraction and peak rate.""" +function envelope_populations!(q, nodes, c, first, count) + envelope_exposure!(q, nodes, c, count) + (; rate, exposure, fractions, peaks) = q + T = typeof(q.dt) + initial, none = T(q.parameters[9]), zero(q.dt) + nt = size(nodes, 1) + each!(c, count, 1) do n, _ + @inbounds begin + peak = none + for t in 1:nt + peak = max(peak, rate[t, n]) + end + e = exposure[nt, n] + fractions[first+n-1] = initial + (1 - initial) * -expm1(-e) + peaks[first+n-1] = peak + end + end + zeros(6) +end diff --git a/julia/src/free.jl b/julia/src/free.jl index cc9295fb1..54429c2b3 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -38,7 +38,12 @@ function create_free(c, host) # and a division (binary64 at an A40's 1/64 rate, about half a Cartesian window). op = wide_eltype(c) === Float64 && oncpu(c) ? map(v -> v isa Array ? upload(c, v) : v, separable) : free_tables(c, separable, nw, nm) - c = merge(c, ( + # The exponential Adams trial reads every element's rate (its phi functions take + # the step's exponent): the host-formed table, the same binary64 values. + adams = host.has("adams_order") && host.int("adams_order") > 0 + linear = !adams ? upload(c, widen_host(wide_eltype(c), zeros(ComplexF64, 0, 0))) : + haskey(op, :rate) ? op.rate : free_tables(c, separable, nw, nm).rate + c = merge(c, (linear=linear, spatial_shape=shape, op=op, field_scale=T(host.real("pad_scale")) * scale, absorber_scale=T(-0.5) * scale, spatial_rate=upload(c, T.(spatial_rate)), temporal_rate=upload(c, T.(c.split ? zero(c.rate) : c.rate)), in_stage=in_stage, @@ -68,7 +73,7 @@ function create_free(c, host) pack = (input=pack_in, output=pack_out, forward=plan(c, plan_rfft, pack_in, 1)) end work = ( - adams=nothing, path=nothing, raman=raman_workspace(c, host, nt, chunk), monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), held_state=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), + adams=adams_workspace(c, host, nw, nm), path=nothing, raman=raman_workspace(c, host, nt, chunk), monitor=monitor_workspace(c, nw, nm, nc), edge=Ref{Any}(nothing), held_state=Ref{Any}(nothing), march=Ref{Any}(nothing), spatial=Ref{Any}(nothing), plasma=plasma, pack=pack, y=dzeros(c, C, nw, nm), candidate=dzeros(c, C, nw, nm), lab=dzeros(c, C, nw, nm), source=dzeros(c, C, nw, nm), error=dzeros(c, C, nw, nm), diff --git a/julia/src/responses.jl b/julia/src/responses.jl index 240afd658..a82762eae 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -77,6 +77,7 @@ end # --- plasma ------------------------------------------------------------------------- function plasma_workspace(c, host, nt, chunk, nm, nn) + host.flag("envelope_plasma") && return envelope_plasma_workspace(c, host, nt, chunk, nm, nn) host.flag("plasma") || return nothing T = c.T # Columns: the chunk's where the streams are transformed node by node (free space, @@ -341,9 +342,12 @@ pass is a sample a thread and the two running integrals are column-wise scans: t sums are reassociated, which SEP 25 permits and the tests bound, as native's two-level device scans do. """ -plasma_current!(p, nodes, c, count) = each_channel(p) do q, add - oncpu(c) && !SAMPLE_PLASMA[] ? plasma_columns!(q, nodes, c, count, add) : - plasma_samples!(q, nodes, c, count, add) +function plasma_current!(p, nodes, c, count) + is_envelope(p) && return envelope_current!(p, nodes, c, count) + each_channel(p) do q, add + oncpu(c) && !SAMPLE_PLASMA[] ? plasma_columns!(q, nodes, c, count, add) : + plasma_samples!(q, nodes, c, count, add) + end end """Call `f(q, add)` for each plasma channel: `q` the workspace with the channel's rate @@ -351,9 +355,9 @@ table, constants and population tables in place of the first's, `add` whether it currents add to those the channels before it formed.""" function each_channel(f::F, p) where {F} for (k, channel) in enumerate(p.channels) + # (The channel's every table: an envelope's carries its precise rate's tails.) q = k == 1 ? p : - merge(p, (coefficients=channel.coefficients, parameters=channel.parameters, - fractions=view(p.fractions_all, :, k), peaks=view(p.peaks_all, :, k))) + merge(p, channel, (fractions=view(p.fractions_all, :, k), peaks=view(p.peaks_all, :, k))) f(q, k > 1) end end @@ -468,6 +472,7 @@ function add_plasma!(destination, p, plan, c; coarse=false, direct=false) end """Add `-i J / omega + edge / omega^2` of the currents' spectra, already transformed.""" function add_plasma_spectra!(destination, p, c; coarse=false) + is_envelope(p) && return add_envelope_spectra!(destination, p, c) # The coarse quadrature's currents (a GPU's packed streams), or the source's. spectrum, edge_spectrum = coarse ? (p.coarse_spectrum, p.coarse_edge_spectrum) : (p.spectrum, p.edge_spectrum) @@ -489,6 +494,7 @@ and set its nodes' final fractions and peak rates. A GPU forms them a sample a t with the column diagnostics as array reductions, as it forms the current. """ population_parts!(p, nodes, c, first, count) = + is_envelope(p) ? envelope_populations!(p, nodes, c, first, count) : oncpu(c) && !SAMPLE_PLASMA[] ? population_columns!(p, nodes, c, first, count) : population_samples!(p, nodes, c, first, count) @@ -642,6 +648,20 @@ function raman_workspace(c, host, nt, chunk; modes=0, nodes=0, synthesis=nothing signal_forward=thg ? nothing : plan(c, plan_fft!, signal, 1), signal_inverse=thg ? nothing : plan(c, plan_bfft!, signal, 1)) end + # A varying kernel (a gas gradient's): the rows on the device, rebuilt at a stage whose + # rates or densities differ (`rebuild_raman!`), the block exponent the launch's. + if host.flag("raman_varying") + time_kernel = dzeros(c, T, 2nt, 1) + extra = (extra..., varying=true, rows=upload(c, T.(rows)), + component=host.array("raman_component", Int), + fractions=host.array("raman_fractions", Float64), + weights_device=dzeros(c, T, length(rates)), rates_device=dzeros(c, T, length(rates)), + time_kernel=time_kernel, time_spectrum=dzeros(c, C, nt + 1, 1), + kernel_plan=plan(c, plan_rfft, time_kernel, 1; threads=1), + kernel_scale=T(dt / (2nt) * exp2(-e)), raman_dt=T(dt), last=Ref{Any}(nothing)) + else + extra = (extra..., varying=false) + end (kernel=upload(c, C.(spectrum)), factor=host.real("raman_factor") * exp2(e), thg=thg, products=products, drive=drive, frequency=frequency, extra..., forward=plan(c, plan_rfft, drive, 1; threads=c.raman_fft_threads), @@ -659,6 +679,36 @@ function convolve!(r, c) nothing end +"""Rebuild a varying Raman kernel for a stage's decay rates and component densities: the +response `sum_k n_c(k) f_c(k) R_k(t) exp(-r_k t)` on the device, one transform, scaled as +the launch's spectrum was. A stage that repeats the last rates and densities keeps it.""" +function rebuild_raman!(r, rates, densities, c) + key = (copy(rates), copy(densities)) + r.last[] == key && return nothing + r.last[] = key + T = eltype(r.time_kernel) + weights = [densities[r.component[k]] * r.fractions[r.component[k]] for k in eachindex(rates)] + copyto!(r.weights_device, T.(weights)) + copyto!(r.rates_device, T.(rates)) + rows, w, decay, response, dt = r.rows, r.weights_device, r.rates_device, r.time_kernel, r.raman_dt + terms = length(rates) + each!(c, size(response, 1), 1) do t, _ + @inbounds begin + value = zero(eltype(response)) + for k in 1:terms + value += w[k] * rows[t, k] * exp(-decay[k] * (t - 1) * dt) + end + response[t, 1] = value + end + end + mul!(r.time_spectrum, r.kernel_plan, response) + kernel, spectrum, scale = r.kernel, r.time_spectrum, r.kernel_scale + each!(c, length(kernel), 1) do f, _ + @inbounds kernel[f] = spectrum[f, 1] * scale + end + nothing +end + """Convolve each node's drive, `|E|^2` (or half the analytic signal's), with the kernel.""" function raman_drive!(r, nodes, analytic, c, count) nt = size(nodes, 1) diff --git a/julia/src/stages.jl b/julia/src/stages.jl index 53feadbf7..f22d270da 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -19,7 +19,10 @@ function path_workspace(c, host) # channel's density and preionisation. material=[zeros(3, stages); ones(1, stages); zeros(2 * ((host.has("plasma_count") ? host.int("plasma_count") : 1) - 1), stages)], - tables=Dict{String,Any}(), constants=zeros(4)) + tables=Dict{String,Any}(), constants=zeros(4), + # A varying Raman kernel's decay rates (a term a row) and component densities. + raman_rates=zeros(host.flag("raman_varying") ? length(host.array("raman_component", Int)) : 0, stages), + raman_densities=zeros(host.flag("raman_varying") ? length(host.array("raman_fractions", Float64)) : 0, stages)) end """Take a trial's stage weights: Phi increments, prefactor weights and material scales.""" @@ -50,6 +53,10 @@ function material_stage!(engine, stage) end engine.factor = p.material[1, stage] engine.taper = p.material[4, stage] + r = w.raman + if r !== nothing && r.varying && !isempty(p.raman_rates) + rebuild_raman!(r, view(p.raman_rates, :, stage), view(p.raman_densities, :, stage), c) + end if w.plasma !== nothing w.plasma.parameters[8] = p.material[2, stage] w.plasma.parameters[9] = p.material[3, stage] @@ -136,6 +143,14 @@ function configure_stages_at!(engine, z0, positions) for name in ("plasma", "preionisation")] material = permutedims(hcat([kerr * d * scale2 for d in density], column("plasma"), column("preionisation"), taper, later...)) + # A varying Raman kernel's rates and densities, before the stages are configured + # (whose first stage then rebuilds it). + for k in axes(path.raman_rates, 1) + path.raman_rates[k, 1:n] .= column("raman_rate_$k") + end + for j in axes(path.raman_densities, 1) + path.raman_densities[j, 1:n] .= column("raman_density_$j") + end configure_stages!(engine, delta, weights, material) end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 048351a1d..29cff17dd 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -178,7 +178,6 @@ def _refuse(problem: KernelProblem) -> None: problem.stepper, ) reasons = { - "envelope plasma": problem.grid_kind == "envelope" and problem.flags.has_plasma, "single batch and scalar polarisation": problem.shape[0] != 1 or problem.shape[2] != 1 or transform.n_pol != 1, @@ -191,12 +190,12 @@ def _refuse(problem: KernelProblem) -> None: {r.thg for r in response.raman_terms} ) > 1, - "varying Raman coefficients": any( - not _constant(r.density or response.density) - or any(not _constant(v) for v in r.decay_rates) - for r in response.raman_terms - ), - "spectral responses": problem.flags.has_spectral_responses, + # A varying Raman kernel is rebuilt at each stage by the stage machinery, which a + # varying operator brings (a gas gradient's); free space has none. + "varying Raman coefficients beside a constant operator": _raman_varying(problem) + and problem.linear.phi_expansion is None, + "varying Raman coefficients in free space": _raman_varying(problem) + and transform.kind == "free", "dispersive Kerr": response.dispersive_kerr is not None, "separable responses off free space": response.separable is not None and transform.kind != "free", @@ -209,8 +208,6 @@ def _refuse(problem: KernelProblem) -> None: type(stepper.integrator) is not Multistep or stepper.integrator.formulation != "exponential" ), - "Cartesian Adams integration": isinstance(stepper.integrator, Multistep) - and transform.kind == "free", # A modal route's RK4IP flow is the constant operator's exponential; a # varying one's (an integral over the half step) is not formed. "low-storage integration with a varying operator": isinstance( @@ -247,6 +244,16 @@ def _compensated(problem: KernelProblem) -> bool: } and not source_absent(problem) +def _raman_varying(problem: KernelProblem) -> bool: + """Whether any Raman component's density or decay rate varies along the guide.""" + response = problem.responses + return any( + not _constant(r.density or response.density) + or any(not _constant(v) for v in r.decay_rates) + for r in response.raman_terms + ) + + def _varying(problem: KernelProblem) -> bool: """Identify stage-dependent material scales and longitudinal expansions.""" response = problem.responses @@ -260,8 +267,9 @@ def _varying(problem: KernelProblem) -> bool: ) or any( not _constant(c.density) or not _constant(c.preionisation) - for c in response.plasma_channels + for c in response.population_channels ) + or _raman_varying(problem) ) @@ -440,6 +448,48 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: omega=grids.omega.copy(), ) + envelope = responses.envelope_plasma + if envelope is not None: + # The envelope grid's channels: each one's instantaneous table and constants as + # the field plasma's, the cycle quadrature's rules end to end, and the + # currents' spectral factors on the band (julia/src/envelope.jl). + config["envelope_plasma"] = True + config["plasma_count"] = len(envelope.channels) + for k, channel in enumerate(envelope.channels, start=1): + suffix = "" if k == 1 else f"_{k}" + table = channel.cycle.rate + config[f"plasma_coefficients{suffix}"] = table.coefficients.copy() + config[f"plasma_parameters{suffix}"] = np.array( + [ + table.field_min, + table.field_max, + table.rate_max, + table.log_field_min, + table.d_log_field, + channel.charge_mass_ratio, + channel.ionisation_potential / scale**2, + float(channel.density(0.0)), + float(channel.preionisation(0.0)), + ] + ) + rules = envelope.channels[0].cycle.rules + if any( + len(c.cycle.rules) != len(rules) + or any( + not np.array_equal(a.nodes, b.nodes) for a, b in zip(c.cycle.rules, rules, strict=True) + ) + for c in envelope.channels + ): + raise BackendError("julia does not support channels with different rules") + config.update( + envelope_rule_nodes=np.concatenate([r.nodes for r in rules]), + envelope_rule_weights=np.concatenate([r.weights for r in rules]), + envelope_rule_orders=np.array([len(r.nodes) for r in rules], dtype=np.int64), + envelope_drude=envelope.factors.drude.copy(), + envelope_loss=envelope.factors.loss.copy(), + dt=grids.dt_fine, + ) + if responses.raman_terms: # Every component's terms in one kernel, each weighted by its density and # fraction (constant: varying coefficients are refused), the mlx backend's sum. @@ -449,6 +499,19 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: rows.append(raman.undamped.T) rates.extend(float(rate(0.0)) for rate in raman.decay_rates) weights.extend([density * raman.fraction] * len(raman.decay_rates)) + if _raman_varying(problem): + # Each term's component and each component's fraction: the engine forms + # the weights from the stage's densities and rebuilds the kernel. + config["raman_varying"] = True + config["raman_component"] = np.concatenate( + [ + np.full(len(raman.decay_rates), j, dtype=np.int64) + for j, raman in enumerate(responses.raman_terms, start=1) + ] + ) + config["raman_fractions"] = np.array( + [raman.fraction for raman in responses.raman_terms] + ) config.update( raman_undamped=np.ascontiguousarray(np.hstack(rows)), raman_rates=np.array(rates), @@ -825,6 +888,14 @@ def _bind_stage_tables(self) -> None: suffix = "" if k == 1 else f"_{k}" tables[f"plasma{suffix}"] = channel.density tables[f"preionisation{suffix}"] = channel.preionisation + if _raman_varying(problem): + # Each term's decay rate and each component's density, for the kernel the + # engine rebuilds when they change. + rates = [t for r in responses.raman_terms for t in r.decay_rates] + for i, table in enumerate(rates, start=1): + tables[f"raman_rate_{i}"] = table + for j, raman in enumerate(responses.raman_terms, start=1): + tables[f"raman_density_{j}"] = raman.density or responses.density if problem.transform.taper_scale is not None: # A tapered guide's scale: the synthesis takes it, the projection its # reciprocal. diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 324616c2c..2c1d70cf5 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -9,6 +9,7 @@ (``SOLPROP_JULIA_CHECK``), so that a CPU run catches what would fail on a device. """ +import dataclasses import importlib.util import os @@ -54,6 +55,8 @@ def runtime(): ("h2_raman_6ps", "default", 0.0005), ("radial_filament_256", "default", 0.002), ("line", "default", 0.005), + # Free space on the exponential Adams march: past its start-up steps. + ("line", "multistep", 0.02), ("kerr_beam_192", "default", 1.0), ] @@ -537,6 +540,123 @@ def test_julia_two_plasma_channels_match_the_reference(runtime): ) +@pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") +@pytest.mark.filterwarnings("ignore::solprop.exceptions.GasFlowWarning") +@binary64 +def test_julia_varying_raman_matches_the_reference(runtime): + """A hydrogen gradient: the Raman density and decay rates vary along the guide, and + the engine rebuilds its kernel at each stage as the reference does.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.physdata.selection import MaterialSelection # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length, fields = 0.05, {} + with ExitStack() as cleanup: + for name in ("numpy_ref", "julia"): + simulation = Simulation.from_capillary( + 75e-6, length, "H2", (3.0, 0.5), wavelength=800e-9, + wavelength_limits=(300e-9, 3e-6), trange=1e-12, fwhm=30e-15, + energy=50e-6, n_save=2, backend=name, integrator=RungeKutta(), + schedule=FixedSchedule.uniform(0.0, length, length / 16), + absorber_scheme="split_step", noise=None, plasma=False, raman=True, + # The lines' density shift held at the reference density (the seam + # cannot follow it along a gradient). + materials=MaterialSelection(raman_shift="reference-density"), + ) + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + fields[name] = engine.observe(field=True).field + scale = float(np.linalg.norm(fields["numpy_ref"])) + assert float(np.linalg.norm(fields["julia"] - fields["numpy_ref"])) <= 1e-10 * scale + + +ENVELOPE_PLASMA_STATISTICS = ( + "electron_density", + "peak_ionisation_rate", + "species_ionisation", +) + + +def _envelope_plasma(name, waveguide, precision="double"): + """Argon's envelope plasma (preionised 10 %, ionising) on four fixed steps: a + resolved capillary or a mode-averaged waveguide. Return its field and statistics.""" + from contextlib import ExitStack # noqa: PLC0415 + + from rate_oracles import adk_oracle # noqa: PLC0415 + from solprop.boundaries import absorber # noqa: PLC0415 + from solprop.driver import Simulation # noqa: PLC0415 + from solprop.modes import MarcatiliMode # noqa: PLC0415 + from solprop.stats import StatsSpec # noqa: PLC0415 + from solprop.stepper import FixedSchedule, RungeKutta # noqa: PLC0415 + + length = 8e-6 + options = { + "wavelength": 800e-9, "wavelength_limits": (500e-9, 1.2e-6), "trange": 80e-15, + "fwhm": 20e-15, "energy": 4e-4, "envelope": True, "plasma": adk_oracle("Ar"), + "preionisation": 0.1, "raman": False, "kerr": True, "noise": None, + "schedule": FixedSchedule.uniform(0.0, length, length / 4), + "save_planes": [length / 2, length], "integrator": RungeKutta(), + "stats": StatsSpec(names=ENVELOPE_PLASMA_STATISTICS), "precision": precision, + "backend": name, + } + if waveguide: + simulation = Simulation.from_waveguide( + [MarcatiliMode(125e-6, "Ar", 1.0, loss=False, cladding=1.45)], + length, "Ar", 1.0, **options, + ) + else: + simulation = Simulation.from_capillary( + 125e-6, length, "Ar", 1.0, loss=False, cladding=1.45, n_r=4, + radial_rule="gauss", **options, + ) + simulation.settings = dataclasses.replace( + simulation.settings, absorber=absorber(simulation.grid, boundary_length=1e-3) + ) + with ExitStack() as cleanup: + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(length) + return engine.observe(field=True).field, engine.stats( + simulation.translate().stats_spec + ) + + +@pytest.mark.parametrize("waveguide", [False, True]) +@binary64 +def test_julia_envelope_plasma_matches_the_reference(runtime, waveguide): + """The envelope plasma's field and populations are the reference's to rounding.""" + del runtime + field, statistics = _envelope_plasma("julia", waveguide) + reference, expected = _envelope_plasma("numpy_ref", waveguide) + # The rate is live: the cycle quadrature and the loss current are exercised. + assert float(np.max(expected["peak_ionisation_rate"])) > 1e9, expected + scale = float(np.linalg.norm(reference)) + assert float(np.linalg.norm(field - reference)) <= 1e-10 * scale + for name in ENVELOPE_PLASMA_STATISTICS: + np.testing.assert_allclose( + statistics[name], expected[name], rtol=1e-9, err_msg=name + ) + + +@pytest.mark.parametrize("wide", WIDE) +@pytest.mark.parametrize("waveguide", [False, True]) +def test_julia_single_precision_envelope_plasma(runtime, monkeypatch, waveguide, wide): + """Binary32's envelope plasma (its cycle sums compensated) tracks the binary32 + reference as the other windows do, and its populations within the same 1e-4.""" + del runtime + monkeypatch.setenv("SOLPROP_JULIA_WIDE", wide) + field, statistics = _envelope_plasma("julia", waveguide, "single") + reference, expected = _envelope_plasma("numpy_ref", waveguide, "single") + scale = float(np.linalg.norm(reference)) + assert float(np.linalg.norm(field - reference)) <= 1e-4 * scale + for name in ENVELOPE_PLASMA_STATISTICS: + np.testing.assert_allclose( + statistics[name], expected[name], rtol=1e-4, err_msg=name + ) + + @binary64 def test_julia_tsit5_matches_the_reference(runtime): """An adaptive TSIT5 window takes the reference's steps and field.""" @@ -624,7 +744,7 @@ def test_julia_reports_its_engine(runtime): @pytest.mark.filterwarnings("ignore::solprop.exceptions.MaterialRangeWarning") @pytest.mark.parametrize("wide", WIDE) -@pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS[:6]) +@pytest.mark.parametrize(("case", "stepper", "fraction"), WINDOWS[:7]) def test_julia_single_precision_tracks_the_reference( runtime, monkeypatch, case, stepper, fraction, wide ): From 6d697adc885729d58b4551b9bf9a2e335cc0e761 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 08:30:35 +0000 Subject: [PATCH 095/107] Julia experiment: the A40 at 137c6915; STATUS for the new features [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 17 ++++++++++++++ julia/STATUS.md | 50 +++++++++++++++++++++++++++++------------- 2 files changed, 52 insertions(+), 15 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index b9ea52cec..18464b6e5 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3229,3 +3229,20 @@ native's sources do fewer transforms: the analytic signal by one c2c inverse of doubled one-sided spectrum (Julia: a c2r, then an fft/bfft pair), the forward streams packed into one r2c, radial's three streams in one r2c with stacked projections; `h2_raman_6ps`'s Raman is an FFT convolution of 2 n_t on both. + +**NVIDIA A40** at `137c6915` (the free-space operator as host-formed tables on every +GPU, binary64 too, and the fused Kerr pass restored for Kerr alone; DMOG gpu07, 2 % +windows, 3 rounds): against `9d814979` 0.97 in binary64 (`line` 0.88, `kerr_beam_192` +0.91, the rest within 2 %, fields identical or to 1e-15). Against native, binary64 1.81: + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.054 | 0.119 | 2.19 | 0.132 | 2.43 | +| `argon_blueshift` | 0.116 | 0.278 | 2.40 | 0.223 | 1.92 | +| `h2_raman_6ps` | 1.040 | 0.952 | 0.92 | 0.577 | 0.55 | +| `ctc_reduced` | 0.207 | 0.264 | 1.28 | 0.257 | 1.24 | +| `radial_filament_256` | 0.169 | 0.306 | 1.81 | 0.227 | 1.34 | +| `kerr_beam_192` | 0.176 | 0.578 | 3.29 | 0.506 | 3.02 | +| `line` | 0.096 | 0.163 | 1.71 | 0.112 | 1.18 | + +Binary32 with df32 1.48 (2 rounds). diff --git a/julia/STATUS.md b/julia/STATUS.md index cefa8bc85..e43293541 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -182,10 +182,9 @@ place of, native and `mlx`. - **GPU speed.** About twice native on full-rate GPUs (H200 2.39, MI325X 2.48, not re-measured since), host-bound: launches (about 75 a trial), copies and allocations. CUDA graphs or fused trials are the next step, untried. -- **Coverage.** Julia refuses most of what native runs beyond the seven focus routes - (the list below), and several things `mlx` runs (envelope plasma, tapers, batches, - several plasma channels or Raman terms). Each is a feature to write and to test - against `numpy_ref`. +- **Coverage.** Julia refuses much of what native runs beyond the focus routes (the + list below). Of what `mlx` runs, only the on-axis plasma statistics, vector + polarisation and tensor Raman are left (2026-11-08). - **Distribution and start.** A Julia runtime and a 1.8 GB depot beside the wheel; the first engine in a process compiles for 11 to 14 s on a CPU (after the precompiled trace) and about 28 s on Metal. A PackageCompiler system image, untried, @@ -220,25 +219,46 @@ cases. The changes, each A/B'd on Metal (the ledger has the rows): - The analytic signal from the spectrum (as native forms it; no benchmark case uses it). -**`mlx`'s features: 11 of 13 closed**, each tested against `numpy_ref` (binary64, +**`mlx`'s features: 13 of 14 closed** (varying Raman, Adams in free space and +envelope plasma on 2026-11-08, below), and of the evening's list each tested against `numpy_ref` (binary64, fields within 1e-10, most about 1e-15): lockstep batches, TSIT5, modal RK4IP, several Raman components, tapers, the window statistics and `zdw`, resolved and radial envelopes, the envelope's third harmonic, Raman in free space, several plasma channels. +## 2026-11-08 + +Three more `mlx` features, each against `numpy_ref` on DMOG (57 tests pass on the CPU +and on the A40 at `a23cfd3f`): +- **Varying Raman.** Each term's decay rate and each component's density are stage + tables; the kernel is rebuilt when they change (`rebuild_raman!`). Hydrogen's lines + shift with density, which the Raman seam cannot follow along a gradient, so the + test holds the shift at the reference density (`MaterialSelection`). +- **Adams in free space.** The host-formed rate table is the Adams operator; a `line` + window on the multistep stepper, binary64 within 1e-10 and binary32 within 1e-4. +- **Envelope plasma** (`julia/src/envelope.jl`). The oracle's cycle quadrature per + sample (rules of 64 to 512 points, split at the table's cutoffs, refined to 2e-6), + the running trapezoid of the rate, and the drive and loss currents through the field + plasma's projected, transformed streams with -1/omega^2 and -i/omega. Binary32's + refinement needs `mlx`'s precise table evaluation (`precise_rate`: the local + coordinate `log1p(E/E_i - 1)` and a two-sum constant term); a binary32 `log E` put + 4e-5 of noise in the rate and no two rules agreed. Scalar polarisation only, as + everywhere; a sample that does not converge is NaN and the step's norm refuses it + (the oracle raises `ConvergenceError`). + +The A40 at `137c6915`: 0.97 against `9d814979`; native against Julia 1.81 in binary64 +and 1.48 in binary32 df32 (the ledger's table). + ## Next steps Roughly in order of what they would tell. -1. **The remaining `mlx` features.** Varying Raman (each term's decay rate and each - component's density as stage tables; the kernel rebuilt on the device when the - rates change, with a fixed block exponent in binary32), Cartesian Adams (the phi - moments from the free-space rate table, which every GPU now holds), envelope plasma - (a port of `mlx_gpu/envelope.py`), the on-axis plasma statistics (the populations on - an on-axis node). Vector polarisation and tensor Raman are deferred. +1. **The last `mlx` feature:** the on-axis plasma statistics (the populations on the + axis row, `backends/populations.py`). Vector polarisation and tensor Raman are + deferred. 2. **`line` on Metal (1.5 against `mlx`).** About a third of its window is the statistics: `spatial_local!` and the population snapshot read back several arrays a plane. Fold them into one readback; fuse `source_free!`'s elementwise passes. -3. **The A40 against native (about 1.9 binary64, 1.5 binary32 df32).** Fair profiles +3. **The A40 against native (1.81 binary64, 1.48 binary32 df32).** Fair profiles need `nsys --cuda-graph-trace=node` (native's sources run in CUDA graphs). What is left: - Host time between launches (the march and the trial tables while the device @@ -270,9 +290,9 @@ are in the private `solprop-dev/benchmarks/julia-m5-2026-11-07` and ## Not run -Vector polarisation and tensor Raman, noise, envelope plasma, varying Raman -coefficients, dispersive Kerr, TDSE, planar and general modal guides, coupled flows, the -interaction Adams formulation, Adams on free space, the carrier frame, interpolated +Vector polarisation and tensor Raman, noise, varying Raman coefficients beside a +constant operator or in free space, dispersive Kerr, TDSE, planar and general modal +guides, coupled flows, the interaction Adams formulation, the carrier frame, interpolated planes, low-storage integration with a varying operator, tableaux other than DOPRI5 and TSIT5, and the on-axis plasma statistics are refused by name; so is binary64 on Metal. From 51ef674e3d60c34f3bdc9de00d85c451e3bd71ea Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 08:46:30 +0000 Subject: [PATCH 096/107] Julia experiment: on-axis plasma statistics; envelope plasma converges on Metal [skip ci] The on-axis statistics through the driver's shared form (a node on the axis hands over its row, else the axis row is scanned). Envelope plasma in binary32: sin and cos by polynomials on [0, pi/2] (Metal's library is 2-3 ulp, which near the low cutoff exceeded the 2e-6 refinement), the cosine moment alone required to converge (the sine moment enters nothing at a scalar envelope's zero ratio), and a non-converged sample raises the oracle's ConvergenceError. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/envelope.jl | 34 ++++- src/solprop/backends/julia/_backend.py | 181 +++++++++++++++++-------- tests/backends/test_julia.py | 103 +++++++++++--- 3 files changed, 238 insertions(+), 80 deletions(-) diff --git a/julia/src/envelope.jl b/julia/src/envelope.jl index 0831ed0de..4341abaa5 100644 --- a/julia/src/envelope.jl +++ b/julia/src/envelope.jl @@ -83,6 +83,23 @@ backend's `rate_at`). The cycle quadrature's refinement needs it: two rules agre end end +"""`(sin, cos)` of an angle in [0, pi/2] by Taylor polynomials on [0, pi/4] (the +other half by the complement): about one ulp on every device, where a GPU's library +gives two or three (Metal), which near the table's low cutoff, where the rate is +steepest in the field, is more than the refinement's 2e-6 can take. Binary64 keeps the +library's.""" +@inline quadrant_sincos(theta::Float64) = sincos(theta) +@inline function quadrant_sincos(theta::T) where {T} + complement = theta > T(pi) / 4 + x = complement ? T(pi) / 2 - theta : theta + x2 = x * x + sine = x * evalpoly(x2, (T(1), T(-1 / 6), T(1 / 120), T(-1 / 5040), T(1 / 362880), + T(-1 / 39916800))) + cosine = evalpoly(x2, (T(1), T(-1 / 2), T(1 / 24), T(-1 / 720), T(1 / 40320), + T(-1 / 3628800), T(1 / 479001600))) + complement ? (cosine, sine) : (sine, cosine) +end + is_envelope(p) = false is_envelope(p::NamedTuple) = haskey(p, :envelope) @@ -98,7 +115,7 @@ rounding of a cut angle cannot put a node across a cutoff). The sums are compens table, tail, inverse, inverse_tail, low, high, cap, origin, step = args @inbounds for i in first:last theta = muladd(nodes[i] + 1, half, lower) - sine, cosine = sincos(theta) + sine, cosine = quadrant_sincos(theta) c2, s2 = cosine * cosine, sine * sine rate = ceiling ? cap : precise_rate(clamp(major * sqrt(c2), low, high), table, tail, inverse, inverse_tail, cap, origin, step) @@ -141,9 +158,11 @@ does not converge (the oracle's ConvergenceError: the step's norm refuses it)."" previous = rule_moments(major, args, nodes, weights, 1, levels[1]) for k in 2:length(levels) current = rule_moments(major, args, nodes, weights, levels[k-1] + 1, levels[k]) - if all(isfinite, current) && - abs(current[1] - previous[1]) <= budget * max(current[1], floor) && - abs(current[2] - previous[2]) <= budget * max(current[2], floor) + # The cosine moment only: at a scalar envelope's zero ratio the sine moment + # enters neither the rate nor the current, and its integrand (the rate times + # tan^2) is the one binary32 misses the budget on near the low cut. (The oracle + # asks both; a deliberate difference, recorded in julia/STATUS.md.) + if isfinite(current[1]) && abs(current[1] - previous[1]) <= budget * max(current[1], floor) return current[1] end previous = current @@ -235,3 +254,10 @@ function envelope_populations!(q, nodes, c, first, count) end zeros(6) end + +"""Whether the last source left a non-converged sample (NaN) in a channel's rates: the +adapter asks only after a nonfinite norm, to raise the oracle's ConvergenceError.""" +function envelope_failed(engine) + p = engine.work.plasma + p === nothing || !is_envelope(p) ? false : any(isnan, Array(p.rate)) +end diff --git a/src/solprop/backends/julia/_backend.py b/src/solprop/backends/julia/_backend.py index 29cff17dd..193ba496a 100644 --- a/src/solprop/backends/julia/_backend.py +++ b/src/solprop/backends/julia/_backend.py @@ -35,7 +35,7 @@ signed_fluence_widths, ) from solprop.constants import EPS0, C -from solprop.exceptions import BackendError +from solprop.exceptions import BackendError, ConvergenceError from solprop.grid import TimeGrid from solprop.modes.protocol import Mode from solprop.monitor import BoundaryEnergies, BoundaryMonitor @@ -44,6 +44,7 @@ from solprop.profiles import ZProfile from solprop.stats import ( _POYNTING_STATISTICS, + ON_AXIS_PLASMA_STATISTICS, StatsSpec, _power_half_width, _poynting_statistics, @@ -53,6 +54,7 @@ from solprop.stepper import LowStorageRungeKutta, Multistep from solprop.stepper.tableau import DOPRI5, TSIT5 from solprop.translate.chebyshev import PiecewiseChebyshev +from solprop.translate.envelope_plasma import EnvelopePlasmaAssembly from solprop.translate.linop import power_weight_at from solprop.translate.precision import launch_peak, state_scale from solprop.translate.problem import KernelProblem @@ -86,6 +88,7 @@ | _SPECIES_STATS | _HOST_STATS | {"peak_intensity", "quadrature_error", "zdw"} + | frozenset(ON_AXIS_PLASMA_STATISTICS) ) _SPATIAL_STATS = ( frozenset(default_spec("radial", with_profiles=True).names) @@ -190,8 +193,8 @@ def _refuse(problem: KernelProblem) -> None: {r.thg for r in response.raman_terms} ) > 1, - # A varying Raman kernel is rebuilt at each stage by the stage machinery, which a - # varying operator brings (a gas gradient's); free space has none. + # A varying Raman kernel is rebuilt at each stage by the stage machinery, + # which a varying operator brings (a gas gradient's); free space has none. "varying Raman coefficients beside a constant operator": _raman_varying(problem) and problem.linear.phi_expansion is None, "varying Raman coefficients in free space": _raman_varying(problem) @@ -234,6 +237,10 @@ def _refuse(problem: KernelProblem) -> None: refuse_general_leaves(problem, "julia") refuse_carrier_frame(problem, "julia") _refuse_stats(problem.stats_spec, spatial=transform.geometry is not None) + from solprop.backends.populations import axis_refusal # noqa: PLC0415 - a cycle + + if reason := axis_refusal(problem, problem.stats_spec.names): + raise BackendError(reason) def _compensated(problem: KernelProblem) -> bool: @@ -292,6 +299,70 @@ def _refuse_stats(spec: StatsSpec, *, spatial: bool = False) -> None: raise BackendError(f"julia does not support statistics {sorted(missing)}") +def _envelope_configuration( + envelope: EnvelopePlasmaAssembly, scale: float +) -> dict[str, object]: + """Return the envelope grid's plasma for the engine (julia/src/envelope.jl). + + Each channel's instantaneous table and constants as the field plasma's, the cycle + quadrature's rules end to end, and the currents' spectral factors on the band. + + Parameters + ---------- + envelope : solprop.translate.envelope_plasma.EnvelopePlasmaAssembly + The compiled channels and factors. + scale : float + The binary32 state's scale (1 in binary64). + + Returns + ------- + dict + Configuration entries. + + Raises + ------ + BackendError + If the channels' quadrature rules differ. + """ + config: dict[str, object] = { + "envelope_plasma": True, + "plasma_count": len(envelope.channels), + } + for k, channel in enumerate(envelope.channels, start=1): + suffix = "" if k == 1 else f"_{k}" + table = channel.cycle.rate + config[f"plasma_coefficients{suffix}"] = table.coefficients.copy() + config[f"plasma_parameters{suffix}"] = np.array( + [ + table.field_min, + table.field_max, + table.rate_max, + table.log_field_min, + table.d_log_field, + channel.charge_mass_ratio, + channel.ionisation_potential / scale**2, + float(channel.density(0.0)), + float(channel.preionisation(0.0)), + ] + ) + rules = envelope.channels[0].cycle.rules + for channel in envelope.channels: + theirs = channel.cycle.rules + if len(theirs) != len(rules) or any( + not np.array_equal(a.nodes, b.nodes) + for a, b in zip(theirs, rules, strict=True) + ): + raise BackendError("julia does not support channels with different rules") + config.update( + envelope_rule_nodes=np.concatenate([r.nodes for r in rules]), + envelope_rule_weights=np.concatenate([r.weights for r in rules]), + envelope_rule_orders=np.array([len(r.nodes) for r in rules], dtype=np.int64), + envelope_drude=envelope.factors.drude.copy(), + envelope_loss=envelope.factors.loss.copy(), + ) + return config + + def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: """Copy the validated constant seam into Julia's frequency-first layout. @@ -448,47 +519,9 @@ def _configuration(problem: KernelProblem, threads: int) -> dict[str, object]: omega=grids.omega.copy(), ) - envelope = responses.envelope_plasma - if envelope is not None: - # The envelope grid's channels: each one's instantaneous table and constants as - # the field plasma's, the cycle quadrature's rules end to end, and the - # currents' spectral factors on the band (julia/src/envelope.jl). - config["envelope_plasma"] = True - config["plasma_count"] = len(envelope.channels) - for k, channel in enumerate(envelope.channels, start=1): - suffix = "" if k == 1 else f"_{k}" - table = channel.cycle.rate - config[f"plasma_coefficients{suffix}"] = table.coefficients.copy() - config[f"plasma_parameters{suffix}"] = np.array( - [ - table.field_min, - table.field_max, - table.rate_max, - table.log_field_min, - table.d_log_field, - channel.charge_mass_ratio, - channel.ionisation_potential / scale**2, - float(channel.density(0.0)), - float(channel.preionisation(0.0)), - ] - ) - rules = envelope.channels[0].cycle.rules - if any( - len(c.cycle.rules) != len(rules) - or any( - not np.array_equal(a.nodes, b.nodes) for a, b in zip(c.cycle.rules, rules, strict=True) - ) - for c in envelope.channels - ): - raise BackendError("julia does not support channels with different rules") - config.update( - envelope_rule_nodes=np.concatenate([r.nodes for r in rules]), - envelope_rule_weights=np.concatenate([r.weights for r in rules]), - envelope_rule_orders=np.array([len(r.nodes) for r in rules], dtype=np.int64), - envelope_drude=envelope.factors.drude.copy(), - envelope_loss=envelope.factors.loss.copy(), - dt=grids.dt_fine, - ) + if responses.envelope_plasma is not None: + config.update(_envelope_configuration(responses.envelope_plasma, scale)) + config["dt"] = grids.dt_fine if responses.raman_terms: # Every component's terms in one kernel, each weighted by its density and @@ -825,6 +858,8 @@ def _trial_step(self, z: float, dz: float) -> tuple[float, object]: ------ BackendError If the trial produces a nonfinite norm or state is unavailable. + ConvergenceError + If an envelope plasma's cycle moments did not converge. """ self._require_state() if self._varying: @@ -833,6 +868,14 @@ def _trial_step(self, z: float, dz: float) -> tuple[float, object]: self._rk_source_evaluations += 6 if self._fsal else 7 self._fsal = True if not np.isfinite(norm): + if self._problem.responses.envelope_plasma is not None and bool( + call_julia(self._jl.envelope_failed, self._engine) + ): + # The engine marks a sample whose cycle moments did not converge NaN, + # which the norm carries here; the oracle raises this. + raise ConvergenceError( + "envelope plasma directional moments did not converge by order 512" + ) raise BackendError("julia produced a nonfinite trial error norm") return norm, self._engine @@ -1159,13 +1202,14 @@ def stats(self, spec: StatsSpec) -> dict[str, np.ndarray]: ) ) if _SPECIES_STATS.intersection(spec.names): - values.update(self._populations(spec, state)) + values.update(self._populations(spec, self._population_scan())) return {name: value[None] for name, value in values.items()} weighted = not np.all(self._weight == 1.0) owned = ( (_POYNTING_STATISTICS if weighted else {"peak_intensity"}) | _SPECIES_STATS | {"quadrature_error"} + | frozenset(ON_AXIS_PLASMA_STATISTICS) ) delegated = dataclasses.replace( spec, names=tuple(n for n in spec.names if n not in owned), periodic=() @@ -1186,8 +1230,15 @@ def stats(self, spec: StatsSpec) -> dict[str, np.ndarray]: values.update(self._poynting(spec, grid, state, axis)) if "quadrature_error" in spec.names: values["quadrature_error"] = np.asarray(self._alarm) - if _SPECIES_STATS.intersection(spec.names): - values.update(self._populations(spec, state)) + axis_names = set(ON_AXIS_PLASMA_STATISTICS).intersection(spec.names) + if _SPECIES_STATS.intersection(spec.names) or axis_names: + scan = self._population_scan() + values.update(self._populations(spec, scan)) + if axis_names: + # The shared form (SEP 19): a node on the axis hands over its row of + # this observation's scan, else the axis row is scanned on the host. + axis = self._axis_statistics(state, scan[:2]) + values.update({name: axis[name] for name in axis_names}) return {name: value[None] for name, value in values.items()} def _poynting( @@ -1414,22 +1465,32 @@ def _bind_poynting(self, axis: np.ndarray | None) -> None: call_julia(self._jl.rebind_weight_b, self._engine, weight) self._poynting_weight = self._weight - def _populations(self, spec: StatsSpec, state: np.ndarray) -> dict[str, np.ndarray]: + def _population_scan(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Scan the held state's populations. + + Returns + ------- + tuple of numpy.ndarray + Each channel's final fraction and peak rate at every node (a row a + channel), and the column diagnostics' maxima. + """ + if not self._problem.flags.has_plasma: + empty = np.zeros((0, self._problem.transform.n_nodes)) + return empty, empty, np.zeros(6) + # The engine reads the state it holds, which is the one observed. + raw = call_julia(self._jl.population_snapshot, self._engine, None) + fractions, peaks = ( + np.atleast_2d(np.asarray(raw[i], dtype=float)) for i in (0, 1) + ) + return fractions, peaks, np.asarray(raw[2], dtype=float) + + def _populations( + self, spec: StatsSpec, scan: tuple[np.ndarray, np.ndarray, np.ndarray] + ) -> dict[str, np.ndarray]: """Reduce fresh accepted-field populations at an observation.""" from solprop.backends.populations import population_statistics # noqa: PLC0415 - parts = np.zeros(6) - if self._problem.flags.has_plasma: - # The engine reads the state it holds, which is the one observed. - del state - raw = call_julia(self._jl.population_snapshot, self._engine, None) - # A row a channel. - fractions, peaks = ( - np.atleast_2d(np.asarray(raw[i], dtype=float)) for i in (0, 1) - ) - parts = np.asarray(raw[2], dtype=float) - else: - fractions = peaks = np.zeros((0, self._problem.transform.n_nodes)) + fractions, peaks, parts = scan values = population_statistics(self._problem, self._z, fractions, peaks) if fractions.shape[0] == 1: values["peak_ionisation_rate"] = np.asarray( diff --git a/tests/backends/test_julia.py b/tests/backends/test_julia.py index 2c1d70cf5..38a2b6bcf 100644 --- a/tests/backends/test_julia.py +++ b/tests/backends/test_julia.py @@ -124,7 +124,7 @@ def test_julia_matches_the_reference(runtime, case, stepper, fraction): @binary64 -def _fixed_capillary(backend, *, integrator=None, fixed=True): +def _fixed_capillary(backend, *, integrator=None, fixed=True, **extra): """A short ionising capillary, on 16 fixed steps (a batch runs a fixed schedule) or adaptive.""" from solprop.driver import Simulation # noqa: PLC0415 @@ -148,6 +148,7 @@ def _fixed_capillary(backend, *, integrator=None, fixed=True): schedule=schedule, absorber_scheme="split_step", noise=None, + **extra, ) @@ -557,11 +558,23 @@ def test_julia_varying_raman_matches_the_reference(runtime): with ExitStack() as cleanup: for name in ("numpy_ref", "julia"): simulation = Simulation.from_capillary( - 75e-6, length, "H2", (3.0, 0.5), wavelength=800e-9, - wavelength_limits=(300e-9, 3e-6), trange=1e-12, fwhm=30e-15, - energy=50e-6, n_save=2, backend=name, integrator=RungeKutta(), + 75e-6, + length, + "H2", + (3.0, 0.5), + wavelength=800e-9, + wavelength_limits=(300e-9, 3e-6), + trange=1e-12, + fwhm=30e-15, + energy=50e-6, + n_save=2, + backend=name, + integrator=RungeKutta(), schedule=FixedSchedule.uniform(0.0, length, length / 16), - absorber_scheme="split_step", noise=None, plasma=False, raman=True, + absorber_scheme="split_step", + noise=None, + plasma=False, + raman=True, # The lines' density shift held at the reference density (the seam # cannot follow it along a gradient). materials=MaterialSelection(raman_shift="reference-density"), @@ -580,7 +593,9 @@ def test_julia_varying_raman_matches_the_reference(runtime): ) -def _envelope_plasma(name, waveguide, precision="double"): +def _envelope_plasma( + name, waveguide, precision="double", energy=4e-4, names=ENVELOPE_PLASMA_STATISTICS +): """Argon's envelope plasma (preionised 10 %, ionising) on four fixed steps: a resolved capillary or a mode-averaged waveguide. Return its field and statistics.""" from contextlib import ExitStack # noqa: PLC0415 @@ -594,23 +609,43 @@ def _envelope_plasma(name, waveguide, precision="double"): length = 8e-6 options = { - "wavelength": 800e-9, "wavelength_limits": (500e-9, 1.2e-6), "trange": 80e-15, - "fwhm": 20e-15, "energy": 4e-4, "envelope": True, "plasma": adk_oracle("Ar"), - "preionisation": 0.1, "raman": False, "kerr": True, "noise": None, + "wavelength": 800e-9, + "wavelength_limits": (500e-9, 1.2e-6), + "trange": 80e-15, + "fwhm": 20e-15, + "energy": energy, + "envelope": True, + "plasma": adk_oracle("Ar"), + "preionisation": 0.1, + "raman": False, + "kerr": True, + "noise": None, "schedule": FixedSchedule.uniform(0.0, length, length / 4), - "save_planes": [length / 2, length], "integrator": RungeKutta(), - "stats": StatsSpec(names=ENVELOPE_PLASMA_STATISTICS), "precision": precision, + "save_planes": [length / 2, length], + "integrator": RungeKutta(), + "stats": StatsSpec(names=names), + "precision": precision, "backend": name, } if waveguide: simulation = Simulation.from_waveguide( [MarcatiliMode(125e-6, "Ar", 1.0, loss=False, cladding=1.45)], - length, "Ar", 1.0, **options, + length, + "Ar", + 1.0, + **options, ) else: simulation = Simulation.from_capillary( - 125e-6, length, "Ar", 1.0, loss=False, cladding=1.45, n_r=4, - radial_rule="gauss", **options, + 125e-6, + length, + "Ar", + 1.0, + loss=False, + cladding=1.45, + n_r=4, + radial_rule="gauss", + **options, ) simulation.settings = dataclasses.replace( simulation.settings, absorber=absorber(simulation.grid, boundary_length=1e-3) @@ -640,6 +675,37 @@ def test_julia_envelope_plasma_matches_the_reference(runtime, waveguide): ) +@pytest.mark.parametrize("grid_kind", ["field", "envelope"]) +@binary64 +def test_julia_on_axis_plasma_statistics_match_the_reference(runtime, grid_kind): + """The on-axis plasma statistics on a resolved capillary (no node on the axis, so + the axis row is scanned): the reference's, on the field and envelope grids.""" + del runtime + from contextlib import ExitStack # noqa: PLC0415 + + from solprop.stats import ON_AXIS_PLASMA_STATISTICS, StatsSpec # noqa: PLC0415 + + names = ("electron_density", *ON_AXIS_PLASMA_STATISTICS) + statistics = {} + for name in ("numpy_ref", "julia"): + if grid_kind == "envelope": + _, statistics[name] = _envelope_plasma(name, False, names=names) + continue + simulation = _fixed_capillary( + name, n_r=4, radial_rule="gauss", stats=StatsSpec(names=names) + ) + with ExitStack() as cleanup: + engine = _loaded(simulation, name, cleanup) + engine.propagate_to(0.004) + statistics[name] = engine.stats(simulation.translate().stats_spec) + expected = statistics["numpy_ref"] + assert float(np.max(expected["on_axis_peak_ionisation_rate"])) > 0 + for name in names: + np.testing.assert_allclose( + statistics["julia"][name], expected[name], rtol=1e-9, err_msg=name + ) + + @pytest.mark.parametrize("wide", WIDE) @pytest.mark.parametrize("waveguide", [False, True]) def test_julia_single_precision_envelope_plasma(runtime, monkeypatch, waveguide, wide): @@ -729,7 +795,11 @@ def test_julia_batch_members_are_their_solo_runs(runtime): def test_julia_reports_its_engine(runtime): """Metadata names the runtime and the sources; the ledger counts owned arrays.""" del runtime - configuration = CASES["rdw"].configuration("rk", 1, "julia", fraction=0.001) + # Metal has binary32 only: a complex sample is 8 bytes there, 16 elsewhere. + single = DEVICE == "metal" + configuration = CASES["rdw"].configuration( + "rk", 1, "julia32" if single else "julia", fraction=0.001 + ) simulation = build(configuration | {"noise": "none"}) problem = simulation.translate() engine = select("julia", problem, grid=simulation.grid, modes=simulation.modes) @@ -738,7 +808,8 @@ def test_julia_reports_its_engine(runtime): assert len(metadata["julia_source_digest"]) == 64 assert metadata["device"].startswith(DEVICE) ledger = engine.memory_ledger() - assert ledger["work.y"] == 16 * problem.shape[1] * problem.shape[3] + width = 8 if single else 16 + assert ledger["work.y"] == width * problem.shape[1] * problem.shape[3] engine.close() From db522ea388d19274cab5b469bee4e5ca998e72c9 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 09:34:03 +0000 Subject: [PATCH 097/107] Julia experiment: four-step long FFTs and transposed transverse planes on CUDA [skip ci] cuFFT runs a binary64 transform of a few thousand points as one block (96 us at 5120 on an A40, any batch); LongFFT splits it n = n1 n2 (23 us). Cartesian transverse transforms through a transverse-first copy: A40 0.92/0.89 binary64 (Metal slower, so CUDA only). Section timers on the free-space DOPRI stages; julia/profile.py takes SOLPROP_PYTHON_PROFILE=1. 59 tests pass on the A40. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 13 ++++ julia/STATUS.md | 41 +++++++++-- julia/ext/SolpropJuliaCUDAExt.jl | 5 ++ julia/profile.py | 14 ++++ julia/src/dopri.jl | 6 +- julia/src/free.jl | 33 ++++++++- julia/src/launch.jl | 123 ++++++++++++++++++++++++++++++- 7 files changed, 222 insertions(+), 13 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 18464b6e5..b095c9f86 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3246,3 +3246,16 @@ windows, 3 rounds): against `9d814979` 0.97 in binary64 (`line` 0.88, `kerr_beam | `line` | 0.096 | 0.163 | 1.71 | 0.112 | 1.18 | Binary32 with df32 1.48 (2 rounds). + +**NVIDIA A40, the Cartesian transverse transform** through a transverse-first copy +(`Transposed`, against cuFFT's strided planes, the same tree, `SOLPROP_JULIA_TRANSPOSE` +arms, 3 rounds): binary64 `kerr_beam_192` 0.92 (0.88–0.97), `line` 0.89 (0.77–0.96); +binary32 df32 0.88 and 1.00. On the M5 Max GPU (Metal, binary32) the copies cost more +than they save: `kerr_beam_192` 1.10, `line` 1.09, so only CUDA takes them. + +**cuFFT's long binary64 transforms** (A40, `scripts/fft_sizes.jl`, `fft_strided.jl`, +`fft_fourstep2.jl` on DMOG): a 5120-point c2c 96 us and a 10240-point one 138 us at +batches 1 to 12, r2c 50 and 101 (cuFFT 12.4 from CUDA 13.4 and 11.3 from 12.8 alike; +binary32 r2c 7 to 9 us). A 2D 512 x 10 transform is 12 us. The four-step split +(`LongFFT`) takes 23 us at 5120 (256 x 20) and 23 to 25 at 10240 (512 x 20), errors +about 1e-17 of the largest value. diff --git a/julia/STATUS.md b/julia/STATUS.md index e43293541..355ec2d3f 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -248,16 +248,45 @@ and on the A40 at `a23cfd3f`): The A40 at `137c6915`: 0.97 against `9d814979`; native against Julia 1.81 in binary64 and 1.48 in binary32 df32 (the ledger's table). +**The on-axis plasma statistics** (`51ef674e`): through the driver's shared form, on +the field and envelope grids, against `numpy_ref`. That closes `mlx`'s list but for +vector polarisation and tensor Raman (deferred). + +**Envelope plasma on Metal.** Binary32 missed the frozen 2e-6 refinement at a few +samples of most runs, on `mlx` too: `mlx` raises `ConvergenceError` on the test's +argon capillary and waveguide at 0.1 to 0.6 mJ (a finding about `mlx`, not filed). +Two causes: Metal's `sin`/`cos` are 2 to 3 ulp (Julia's binary32 ones on a CPU 0.5), +which near the table's low cutoff, where the rate is steepest in the field, is more +noise than the budget; and the sine moment, which a scalar envelope never uses, has +the rate times tan^2 for its integrand. Polynomial `sin`/`cos` on [0, pi/2] +(`quadrant_sincos`, about 1 ulp on every device) and the cosine moment alone required +to converge make every case converge, on Metal and on CPUs. + +**Where the A40's binary64 time goes** (`rdw`, jl15's node-traced profile): Julia's +kernels take 80 ms against native's 32, and 19 ms of Julia's are 195 cuFFT +transforms of 5120 points at 96 us each. cuFFT runs a binary64 transform of a few +thousand points as one block (96 us at 5120, 138 at 10240, any batch, cuFFT 12.4 and +11.3 alike), while a 2D 512 x 10 transform takes 12 us; native's are mostly a +two-kernel split. A four-step split (`LongFFT`: the short transforms strided, the +twiddles, the long ones contiguous) takes 23 us at either size, errors 1e-17 +(`scripts/fft_fourstep2.jl` on DMOG); the engine now plans one on CUDA for binary64 +transforms of 2048 points or more (`SOLPROP_JULIA_FOURSTEP=0` turns it off). The +Cartesian transverse transform through a transverse-first copy (`Transposed`) gives +0.92 on `kerr_beam_192` and 0.89 on `line` on the A40 (binary64), and 1.10 and 1.09 +on Metal, so it is CUDA's only. + ## Next steps Roughly in order of what they would tell. -1. **The last `mlx` feature:** the on-axis plasma statistics (the populations on the - axis row, `backends/populations.py`). Vector polarisation and tensor Raman are - deferred. -2. **`line` on Metal (1.5 against `mlx`).** About a third of its window is the - statistics: `spatial_local!` and the population snapshot read back several arrays - a plane. Fold them into one readback; fuse `source_free!`'s elementwise passes. +1. **`line` on Metal (1.5 against `mlx`).** GPU-bound (host Python under 10 %, + Julia's host time about a fifth); the statistics' readbacks are fixed (observe 4.7 + of 195 ms). What is left is the source: fusing `source_free!`'s and the DOPRI + stage's elementwise passes would save perhaps 5 ms. +2. **The A40's remaining kernels** after the FFT split: the Adams predictor (0.28 ms + a trial on `rdw`, its phi functions spilling) and the mode-averaged elementwise + kernels at 0.1 ms each over a few thousand elements (latency: too few threads, + long binary64 chains). 3. **The A40 against native (1.81 binary64, 1.48 binary32 df32).** Fair profiles need `nsys --cuda-graph-trace=node` (native's sources run in CUDA graphs). What is left: diff --git a/julia/ext/SolpropJuliaCUDAExt.jl b/julia/ext/SolpropJuliaCUDAExt.jl index 0e6ca955f..9d2b4d612 100644 --- a/julia/ext/SolpropJuliaCUDAExt.jl +++ b/julia/ext/SolpropJuliaCUDAExt.jl @@ -9,5 +9,10 @@ import SolpropJulia SolpropJulia.device_backend(::Val{:cuda}) = (CUDA.allowscalar(false); CUDABackend()) SolpropJulia.device_label(::CUDABackend) = "cuda: " * CUDA.name(CUDA.device()) +# cuFFT's binary64 transforms of a few thousand points run one block a transform +# (96 us at 5120 on an A40): the engine splits them (`LongFFT`). +SolpropJulia.long_transforms(::CUDABackend) = true +# cuFFT's strided transverse planes are 3.4 times contiguous ones (`Transposed`). +SolpropJulia.transposed_planes(::CUDABackend) = true end diff --git a/julia/profile.py b/julia/profile.py index 0e0f22e87..db52c23b3 100644 --- a/julia/profile.py +++ b/julia/profile.py @@ -47,9 +47,23 @@ def profile(row: dict) -> None: Main.seval("Profile.clear(); Profile.start_timer()") jl.clear_timings() jl.clear_counts() + # SOLPROP_PYTHON_PROFILE=1: the host's Python time too (cProfile, by own time). + python = os.environ.get("SOLPROP_PYTHON_PROFILE") == "1" + if python: + # (This script's directory shadows the standard library's `profile`.) + here = os.path.dirname(os.path.abspath(__file__)) # noqa: PTH100, PTH120 + sys.path[:] = [p for p in sys.path if os.path.abspath(p) != here] # noqa: PTH100 + import cProfile # noqa: PLC0415 + import pstats # noqa: PLC0415 + + profiler = cProfile.Profile() + profiler.enable() record, _ = timed_run( simulation, problem, engine, retention, simulation._boundary_monitor() ) + if python: + profiler.disable() + pstats.Stats(profiler, stream=sys.stdout).sort_stats("cumulative").print_stats("julia/_|integrators|_march", 30) if sampling: Main.seval("Profile.stop_timer()") Main.seval( diff --git a/julia/src/dopri.jl b/julia/src/dopri.jl index 7987a1a75..a9c297fa5 100644 --- a/julia/src/dopri.jl +++ b/julia/src/dopri.jl @@ -46,9 +46,9 @@ function trial!(engine, dz::Float64) end continue end - slot = c.free ? free_propagators!(engine, dz * c.nodes_c[stage]) : stage + slot = c.free ? (@section :propagators free_propagators!(engine, dz * c.nodes_c[stage])) : stage row = ntuple(p -> T(dz * c.a[stage, p]), Val(6)) - each!(c, size(y)...) do f, m + @section :stage_input each!(c, size(y)...) do f, m @inbounds begin combination = zero(eltype(y)) for p in 1:stage-1 @@ -58,7 +58,7 @@ function trial!(engine, dz::Float64) end end @section :source source!(engine, lab; quadrature=stage == 7) - each!(c, size(y)...) do f, m + @section :stage_output each!(c, size(y)...) do f, m @inbounds stages[f, m, stage] = inverse[f, m, slot] * source[f, m] end end diff --git a/julia/src/free.jl b/julia/src/free.jl index 54429c2b3..543930d7f 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -82,8 +82,8 @@ function create_free(c, host) physical=physical, loss=dzeros(c, C, in_stage ? nw : 0, in_stage ? nm : 0), fine=fine, modal=modal, projected=projected, analytic=analytic, absorber=dzeros(c, R, nt, chunk), absorber_spec=similar(fine), coarse=coarse, coarse_spec=coarse_spec, - spatial_inverse=plan(c, plan_bfft!, spatial, (2, 3); planes...), - spatial_forward=plan(c, plan_fft!, spatial, (2, 3); planes...), + spatial_inverse=transverse_plan(c, plan_bfft!, spatial, planes), + spatial_forward=transverse_plan(c, plan_fft!, spatial, planes), inverse_plan=c.envelope ? plan(c, plan_bfft, fine, 1) : plan(c, plan_brfft, fine, nt, 1), forward_plan=c.envelope ? plan(c, plan_fft, modal, 1) : plan(c, plan_rfft, modal, 1), analytic_forward=plan(c, plan_fft!, analytic, 1), analytic_inverse=plan(c, plan_bfft!, analytic, 1), @@ -204,6 +204,35 @@ end transverse!(a, plan, c) = (plan * reshape(a, size(a, 1), c.spatial_shape...); nothing) +"""A GPU's transverse transform through a transverse-first copy: the frequency-first +state's planes are strided by n_omega, and cuFFT's strided batched 2D transform at +512 x 192 x 192 took 16.2 ms on an A40 against 4.8 for contiguous planes. The planes +are transposed out, transformed contiguously and transposed back: on an A40 0.92 on +`kerr_beam_192` and 0.89 on `line` in binary64. Metal's MPSGraph takes the strided +planes well (the copies made it 1.10 and 1.09), so a device extension asks for it +(`transposed_planes`). `SOLPROP_JULIA_TRANSPOSE=0` keeps the strided plan, for A/Bs.""" +transposed_planes(backend) = false +struct Transposed{P,B} + plan::P + buffer::B +end +function transverse_plan(c, kind, spatial, planes) + dims = Tuple(2:ndims(spatial)) + (oncpu(c) || !transposed_planes(c.backend) || get(ENV, "SOLPROP_JULIA_TRANSPOSE", "1") == "0") && + return plan(c, kind, spatial, dims; planes...) + buffer = similar(spatial, size(spatial)[2:end]..., size(spatial, 1)) + Transposed(kind(buffer, Tuple(1:ndims(spatial)-1)), buffer) +end +function transverse!(a, p::Transposed, c) + spatial = reshape(a, size(a, 1), c.spatial_shape...) + n = ndims(spatial) + tally!(:transpose, 2) + permutedims!(p.buffer, spatial, (2:n..., 1)) + p.plan * p.buffer + permutedims!(spatial, p.buffer, (n, 1:n-1...)) + nothing +end + """Copy columns `first:first+count-1` of `physical` into the fine spectrum.""" function scatter_columns!(fine, physical, first, count, c) uncrop = c.uncrop diff --git a/julia/src/launch.jl b/julia/src/launch.jl index e80e77a9d..606f57169 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -245,7 +245,7 @@ BLAS's own threads beside Polyester's spinning ones made a four-thread rdw run s times slower than one thread. Measuring overwrites `a`: plan before storing in it. """ function plan(c, kind, a, args...; threads=c.fft_threads, batch=2) - oncpu(c) || return kind(a, args...) + oncpu(c) || return device_plan(c, kind, a, args...) blocks = min(threads, size(a, batch)) blocks <= 1 && return kind(a, args...; flags=plan_flags(), num_threads=1) ranges = [r for r in Iterators.partition(axes(a, batch), cld(size(a, batch), blocks))] @@ -296,7 +296,7 @@ function transform_all!(p, outs::Tuple, ins::Tuple, stage::Ref, c) if held === nothing || size(held[1], 2) != n * columns staged = similar(x, size(x, 1), n * columns) result = similar(first(outs), size(first(outs), 1), n * columns) - held = (staged, result, eltype(x) <: Real ? plan_rfft(staged, 1) : plan_fft(staged, 1)) + held = (staged, result, eltype(x) <: Real ? plan(c, plan_rfft, staged, 1) : plan(c, plan_fft, staged, 1)) stage[] = held end staged, result, batched = held @@ -451,3 +451,122 @@ end timings() = Dict(String(k) => v for (k, v) in TIMES) clear_timings() = (empty!(TIMES); nothing) timing_enabled() = TIMING[] + +# --- Long binary64 transforms on a GPU, four-step ------------------------------------- + +"""Whether the device's library takes long binary64 transforms slowly enough to split +them (`LongFFT`): an extension's hook, false unless it says otherwise.""" +long_transforms(backend) = false + +"""Plan `kind(a, args...)` on a GPU: the library's plan, or a four-step one (`LongFFT`) +for a long binary64 transform along the first dimension where the device asks for it.""" +function device_plan(c, kind, a, args...) + split = long_transforms(c.backend) && get(ENV, "SOLPROP_JULIA_FOURSTEP", "1") != "0" + split || return kind(a, args...) + real_input = kind === plan_rfft + output_real = kind === plan_brfft + n = output_real ? Int(args[1]) : size(a, 1) + region = last(args) + shape = factor_length(n) + (ndims(a) == 2 && region == 1 && real(eltype(a)) === Float64 && shape !== nothing && + (!real_input && !output_real ? true : iseven(n))) || return kind(a, args...) + sign = kind in (plan_fft, plan_fft!, plan_rfft) ? -1 : 1 + LongFFT(c, a, n, shape..., sign, kind in (plan_fft!, plan_bfft!), real_input, output_real) +end + +"""`n = n1 n2` with `n2` the smallest divisor that keeps `n1 <= 512`, for `n >= 2048`; +`nothing` otherwise (short transforms, or a large prime factor).""" +function factor_length(n) + n < 2048 && return nothing + for n2 in cld(n, 512):64 + n % n2 == 0 && return (n ÷ n2, n2) + end + nothing +end + +"""A length-`n` transform along the first dimension as `n = n1 n2`: with `n = a + n1 j` +and `k = n2 p + q`, `X[n2 p + q] = sum_a w_n1^(a p) w_n^(a q) sum_j x[a + n1 j] w_n2^(j q)`. +The samples go to an `(n1, m, n2)` work array, the short transforms run along its last +dimension (one plan, strided), the twiddles, the long transforms along its first +(contiguous), and the result comes back in order. On an A40, cuFFT's own binary64 +transform of 5120 or 10240 points is one block a transform, 96 or 138 us at any batch; +the split takes about 23 (DMOG, `scripts/fft_fourstep2.jl`). Real input is promoted to +complex, and a real output's Hermitian spectrum is completed first: both twice the +arithmetic of a real transform, still a quarter of the time.""" +struct LongFFT{S,L,W,T,C} + short::S + long::L + work::W + twiddle::T + device::C + n::Int + n1::Int + n2::Int + columns::Int + inplace::Bool + real_input::Bool + output_real::Bool + sign::Int + # The same transform over other column counts, planned when first asked. + others::Dict{Int,Any} +end +function LongFFT(c, a, n, n1, n2, sign, inplace, real_input, output_real) + twiddle = upload(c, [cispi(2 * sign * (p - 1) * (j - 1) / n) for p in 1:n1, j in 1:n2]) + # What `each!` reads of the engine's configuration. + device = (backend=c.backend, tasks=c.tasks) + long_columns(a, size(a, 2), twiddle, device, n, n1, n2, sign, inplace, real_input, output_real) +end +function long_columns(a, m, twiddle, device, n, n1, n2, sign, inplace, real_input, output_real) + work = similar(a, ComplexF64, n1, m, n2) + short = sign < 0 ? plan_fft!(work, 3) : plan_bfft!(work, 3) + long = sign < 0 ? plan_fft!(work, 1) : plan_bfft!(work, 1) + LongFFT(short, long, work, twiddle, device, n, n1, n2, m, inplace, real_input, output_real, + sign, Dict{Int,Any}()) +end + +function long_transform!(y, p::LongFFT, x) + m = size(x, 2) + if m != p.columns + q = get!(p.others, m) do + long_columns(p.work, m, p.twiddle, p.device, p.n, p.n1, p.n2, p.sign, p.inplace, + p.real_input, p.output_real) + end + return long_transform!(y, q, x) + end + long_transform!(y, p, x, Val(p.real_input), Val(p.output_real)) +end +function long_transform!(y, p::LongFFT, x, ::Val{R}, ::Val{O}) where {R,O} + (; work, twiddle, n, n1, n2, columns) = p + c = p.device + half = n ÷ 2 + tally!(:long_fft) + # The samples in, `x[a + n1 j]` to `work[a, b, j]`; a half spectrum completed. + each!(c, n, columns) do t, b + @inbounds begin + i = t - 1 + value = O ? (i <= half ? complex(x[t, b]) : conj(complex(x[n-i+1, b]))) : + complex(x[t, b]) + work[i % n1 + 1, b, i ÷ n1 + 1] = value + end + end + p.short * work + flat = reshape(work, n1, columns * n2) + each!(c, n1, columns * n2) do a, r + @inbounds flat[a, r] *= twiddle[a, (r - 1) ÷ columns + 1] + end + p.long * work + # `work[p, b, q]` is `X[n2 p + q]`. + rows = R ? half + 1 : n + each!(c, rows, columns) do t, b + @inbounds begin + k = t - 1 + value = work[k ÷ n2 + 1, b, k % n2 + 1] + y[t, b] = O ? real(value) : value + end + end + y +end + +LinearAlgebra.mul!(y, p::LongFFT, x) = long_transform!(y, p, x) +Base.:*(p::LongFFT, x) = p.inplace ? long_transform!(x, p, x) : + throw(ArgumentError("an out-of-place LongFFT takes mul!")) From 8765b5848235f24255d56b7cf5d2a22a45ce6b97 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 10:58:07 +0000 Subject: [PATCH 098/107] Julia experiment: inline kernel bodies on GPUs; per-kernel timer [skip ci] The GPU kernel called its body as a device function per sample (arguments through local memory): 9x slower in binary64 and 20x in binary32 on an A40 than inlined. @inline f(t, m) in each_kernel!, reductions through it: A40 binary64 0.70 over the seven cases (fields identical); Metal neutral. SOLPROP_JULIA_KERNEL_TIMING=1 times each GPU pass by its body. 58 of 59 CUDA tests (the compile-time window is marginal: it passes alone), 13 Metal. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 12 +++++++++ julia/src/SolpropJulia.jl | 1 + julia/src/launch.jl | 52 ++++++++++++++++++++++++++------------- 3 files changed, 48 insertions(+), 17 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index b095c9f86..0130f2dbe 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3259,3 +3259,15 @@ batches 1 to 12, r2c 50 and 101 (cuFFT 12.4 from CUDA 13.4 and 11.3 from 12.8 al binary32 r2c 7 to 9 us). A 2D 512 x 10 transform is 12 us. The four-step split (`LongFFT`) takes 23 us at 5120 (256 x 20) and 23 to 25 at 10240 (512 x 20), errors about 1e-17 of the largest value. + +**NVIDIA A40, inlined kernel bodies** (jl21, `db522ea3` against the same with +`@inline f(t, m)` in the GPU kernel and the reductions through it; two trees, 3 +rounds, binary64): 0.70. `rdw` 0.64, `argon_blueshift` 0.59, radial 0.64, +`kerr_beam_192` 0.80, `ctc_reduced` 0.55, `h2_raman_6ps` 0.68, `line` 1.14 (range +1.06–1.97, fields identical; noisy in every run that day). Left to the inliner, a body +of a few operations was a device call a sample with its arguments in local memory: a +1.08 M-sample cube took 296 us against a broadcast's 34, and 33 inlined (binary32 270 +against 13; `scripts/each_cost3.jl`). On the M5 Max GPU the change is neutral (1.01, +fields identical): Apple's compiler inlines them itself. The four-step transforms +alone (jl20, the same day): 0.99 (`argon_blueshift` 0.94, `ctc_reduced` 0.92); native +against Julia at `db522ea3` 1.80 in binary64. diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 5717688f7..329c7861e 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -65,6 +65,7 @@ real_type(engine) = real(eltype(engine.work.y)) # Read at load, not at precompilation: a constant would be baked into the cache. function __init__() TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "1" + KERNEL_TIMING[] = get(ENV, "SOLPROP_JULIA_KERNEL_TIMING", "0") == "1" COUNT[] = get(ENV, "SOLPROP_JULIA_COUNT", "0") == "1" CHECK[] = get(ENV, "SOLPROP_JULIA_CHECK", "0") == "1" SAMPLE_PLASMA[] = get(ENV, "SOLPROP_JULIA_PLASMA", "columns") == "samples" diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 606f57169..4bc6c27f4 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -97,16 +97,40 @@ function tiling(tasks, nt, nm, heavy=false) pieces, cld(nt, pieces) end +# The body inlined at the call (as the CPU loops do): left to the inliner, a body of a +# few operations became a device call per sample, its arguments through local memory, +# 9 times slower in binary64 and 20 in binary32 on an A40 (a 1.08 M-sample cube, 296 +# against 33 us; DMOG `scripts/each_cost3.jl`). KA.@kernel inbounds = true function each_kernel!(f) t, m = KA.@index(Global, NTuple) - f(t, m) + @inline f(t, m) end function each_on!(f::F, backend, tasks, nt, nm, heavy) where {F} tally!(:launch) + if KERNEL_TIMING[] + SYNCHRONIZE[]() + started = time_ns() + each_kernel!(backend, (256, 1))(f; ndrange=(nt, nm)) + SYNCHRONIZE[]() + time_kernel!(F, nt * nm, time_ns() - started) + return nothing + end each_kernel!(backend, (256, 1))(f; ndrange=(nt, nm)) nothing end +# SOLPROP_JULIA_KERNEL_TIMING=1: each GPU pass timed alone (synchronised around it), +# by the body's name and size: which closure a profiler's generic kernel is. +const KERNEL_TIMING = Ref(false) +const KERNEL_TIMES = Dict{String,Tuple{Int,Float64,Int}}() +function time_kernel!(::Type{F}, size, elapsed) where {F} + name = replace(string(nameof(F)), r"#+" => "#") + count, total, _ = get(KERNEL_TIMES, name, (0, 0.0, size)) + KERNEL_TIMES[name] = (count + 1, total + elapsed * 1e-9, size) +end +kernel_timings() = Dict(k => collect(v) for (k, v) in KERNEL_TIMES) +clear_kernel_timings() = empty!(KERNEL_TIMES) + """A device scratch array the engine keeps (`c.scratch`), by its use, type and shape: a GPU's pool allocations a trial were dozens.""" scratch(c, use::Symbol, T, dims...) = @@ -117,7 +141,7 @@ a device reduction over its rows or columns.""" function reduce_terms(f::F, c, out, nt, nm; use=:terms) where {F} scratch = SolpropJulia.scratch(c, use, eltype(out), nt, nm) each!(c, nt, nm) do t, m - @inbounds scratch[t, m] = f(t, m) + @inbounds scratch[t, m] = @inline f(t, m) end scratch end @@ -188,21 +212,15 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=fa return foldl(op, partials; init=neutral) end tally!(:readback) - if heavy - # A heavy body a thread: AK's reduction gives each thread several elements - # (six blocks for rdw's 10244, its predictor 539 us a trial on an A40), so the - # bodies run as an elementwise kernel into scratch and only the sums reduce. - scratch = SolpropJulia.scratch(c, :heavy, typeof(neutral), nt * nm) - each!(c, nt, nm) do t, m - @inbounds scratch[t+(m-1)*nt] = f(t, m) - end - return AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, - neutral=neutral) - end - AK.mapreduce(op, 1:nt*nm; backend=c.backend, init=neutral, neutral=neutral) do i - m = (i - 1) ÷ nt + 1 - f(i - (m - 1) * nt, m) + # The bodies run as an elementwise kernel into scratch, inlined (`each_kernel!`), and + # only the values reduce: inside AK's reduction the body was a device call per + # element, and a heavy one got several elements a thread (six blocks for rdw's + # 10244, its predictor 539 us a trial on an A40). + scratch = SolpropJulia.scratch(c, heavy ? :heavy : :reduce, typeof(neutral), nt * nm) + each!(c, nt, nm) do t, m + @inbounds scratch[t+(m-1)*nt] = @inline f(t, m) end + AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, neutral=neutral) end """The sum of `f(t, m)` over every sample into `out[1]`, which the next kernel reads: on a @@ -216,7 +234,7 @@ function sum_device!(f::F, out, c, nt::Integer, nm::Integer; heavy=false) where end terms = SolpropJulia.scratch(c, :sum_terms, eltype(out), 1, nt * nm) each!(c, nt, nm) do t, m - @inbounds terms[1, t+(m-1)*nt] = f(t, m) + @inbounds terms[1, t+(m-1)*nt] = @inline f(t, m) end tally!(:launch) sum!(reshape(out, 1, 1), terms) From 67491bf98d47eac51ef3b91373901e5f0887c360 Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 12:18:10 +0000 Subject: [PATCH 099/107] Julia experiment: tiled device transposes, kept reduction workspaces [skip ci] The transverse planes' copies through a 32 x 32 local-memory tile (GPUArrays' permutedims took 2.65 ms for a 384 x 36864 state on an A40); AK reductions reuse their scratch (dozens of pool allocations a step on rdw). The FFT levers can be asked for on any GPU (SOLPROP_JULIA_FOURSTEP=1, SOLPROP_JULIA_TRANSPOSE=1). 59 CUDA tests pass, 13 Metal. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- julia/src/free.jl | 14 ++++++++------ julia/src/launch.jl | 37 +++++++++++++++++++++++++++++++++++-- 2 files changed, 43 insertions(+), 8 deletions(-) diff --git a/julia/src/free.jl b/julia/src/free.jl index 543930d7f..f39c86024 100644 --- a/julia/src/free.jl +++ b/julia/src/free.jl @@ -211,7 +211,7 @@ are transposed out, transformed contiguously and transposed back: on an A40 0.92 `kerr_beam_192` and 0.89 on `line` in binary64. Metal's MPSGraph takes the strided planes well (the copies made it 1.10 and 1.09), so a device extension asks for it (`transposed_planes`). `SOLPROP_JULIA_TRANSPOSE=0` keeps the strided plan, for A/Bs.""" -transposed_planes(backend) = false +transposed_planes(backend) = get(ENV, "SOLPROP_JULIA_TRANSPOSE", "") == "1" struct Transposed{P,B} plan::P buffer::B @@ -224,12 +224,14 @@ function transverse_plan(c, kind, spatial, planes) Transposed(kind(buffer, Tuple(1:ndims(spatial)-1)), buffer) end function transverse!(a, p::Transposed, c) - spatial = reshape(a, size(a, 1), c.spatial_shape...) - n = ndims(spatial) - tally!(:transpose, 2) - permutedims!(p.buffer, spatial, (2:n..., 1)) + # The state (n_omega, n_x n_y) and the planes (n_x n_y, n_omega) are each other's + # transposes as matrices. + nw = size(a, 1) + planes = reshape(p.buffer, :, nw) + state = reshape(a, nw, :) + transpose_device!(planes, state, c) p.plan * p.buffer - permutedims!(spatial, p.buffer, (n, 1:n-1...)) + transpose_device!(state, planes, c) nothing end diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 4bc6c27f4..5b029321d 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -131,6 +131,32 @@ end kernel_timings() = Dict(k => collect(v) for (k, v) in KERNEL_TIMES) clear_kernel_timings() = empty!(KERNEL_TIMES) +"""`out = transpose(inp)` for two device matrices, through 32 x 32 tiles in local memory: +both the reads and the writes coalesced. GPUArrays' `permutedims!` took 2.65 ms to +transpose a 384 x 36864 binary64 complex state on an A40, three times the copy's.""" +function transpose_device!(out, inp, c) + n1, n2 = size(inp) + tally!(:transpose) + transpose_kernel!(c.backend, (32, 32))(out, inp; ndrange=(cld(n1, 32) * 32, cld(n2, 32) * 32)) + out +end +KA.@kernel inbounds = true function transpose_kernel!(out, @Const(inp)) + ti, tj = KA.@index(Local, NTuple) + bi, bj = KA.@index(Group, NTuple) + tile = KA.@localmem eltype(out) (33, 32) + n1, n2 = size(inp) + i, j = (bi - 1) * 32 + ti, (bj - 1) * 32 + tj + if i <= n1 && j <= n2 + tile[ti, tj] = inp[i, j] + end + KA.@synchronize + # The tile's transpose, to the block on the other side of the diagonal. + p, q = (bj - 1) * 32 + ti, (bi - 1) * 32 + tj + if p <= n2 && q <= n1 + out[p, q] = tile[tj, ti] + end +end + """A device scratch array the engine keeps (`c.scratch`), by its use, type and shape: a GPU's pool allocations a trial were dozens.""" scratch(c, use::Symbol, T, dims...) = @@ -220,7 +246,14 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=fa each!(c, nt, nm) do t, m @inbounds scratch[t+(m-1)*nt] = @inline f(t, m) end - AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, neutral=neutral) + # The reduction's own scratch, kept (AK's `workspace`): a new partials buffer a call + # was an allocation from the pool and its copies, dozens a step. + workspace = get!(c.scratch, (:reduce_workspace, typeof(op), typeof(neutral), nt * nm)) do + AK.workspace(AK.mapreduce, identity, op, scratch; backend=c.backend, init=neutral, + neutral=neutral) + end + AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, neutral=neutral, + workspace=workspace) end """The sum of `f(t, m)` over every sample into `out[1]`, which the next kernel reads: on a @@ -474,7 +507,7 @@ timing_enabled() = TIMING[] """Whether the device's library takes long binary64 transforms slowly enough to split them (`LongFFT`): an extension's hook, false unless it says otherwise.""" -long_transforms(backend) = false +long_transforms(backend) = get(ENV, "SOLPROP_JULIA_FOURSTEP", "") == "1" """Plan `kind(a, args...)` on a GPU: the library's plan, or a four-step one (`LongFFT`) for a long binary64 transform along the first dimension where the device asks for it.""" From 5421d04ac7e8b37d96e602881bf8540689d6d96d Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 13:37:26 +0000 Subject: [PATCH 100/107] Julia experiment: the A40 at 8765b584 and the H200 at 67491bf9 in the ledger [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 0130f2dbe..84edee418 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3271,3 +3271,41 @@ against 13; `scripts/each_cost3.jl`). On the M5 Max GPU the change is neutral (1 fields identical): Apple's compiler inlines them itself. The four-step transforms alone (jl20, the same day): 0.99 (`argon_blueshift` 0.94, `ctc_reduced` 0.92); native against Julia at `db522ea3` 1.80 in binary64. + +**NVIDIA A40 against native at `8765b584`** (inlined bodies; jl21, 2026-11-08, 3 rounds +binary64, 2 binary32): + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.054 | 0.074 | 1.39 | 0.074 | 1.32 | +| `argon_blueshift` | 0.115 | 0.157 | 1.37 | 0.182 | 1.58 | +| `h2_raman_6ps` | 1.039 | 0.647 | 0.62 | 0.339 | 0.33 | +| `ctc_reduced` | 0.206 | 0.131 | 0.63 | 0.101 | 0.49 | +| `radial_filament_256` | 0.168 | 0.247 | 1.47 | 0.171 | 1.02 | +| `kerr_beam_192` | 0.171 | 0.501 | 2.85 | 0.338 | 1.98 | +| `line` | 0.093 | 0.148 | 1.59 | 0.135 | 1.43 | + +Geometric means 1.26 (binary64) and 1.00 (binary32 df32); the morning's, at `db522ea3`, +1.80 and 1.56. Nsight on `rdw` at the same commit: Julia's kernels 31.1 ms against +native's 31.7, so what is left there is the host's (76 launches a step against native's +40 and one graph, 21 pool allocations and 21 small copies a step). + +**NVIDIA H200** (DigitalOcean, atl1, driver 580.196, CUDA 13.1, 24 host cores) at +`67491bf9`: native's CUDA build (HOPPER90, 8 minutes) against `julia` (CUDA.jl on the +local toolkit), `--device`, 2 % windows; the Julia GPU tests passed there (33 selected). + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.038 | 0.071 | 1.85 | 0.087 | 2.04 | +| `argon_blueshift` | 0.070 | 0.145 | 2.10 | 0.136 | 1.93 | +| `h2_raman_6ps` | 0.223 | 0.313 | 1.39 | 0.373 | 1.67 | +| `ctc_reduced` | 0.070 | 0.081 | 1.16 | 0.101 | 1.46 | +| `radial_filament_256` | 0.061 | 0.106 | 1.73 | 0.100 | 1.65 | +| `kerr_beam_192` | 0.188 | 0.428 | 2.26 | 0.355 | 1.82 | +| `line` | 0.061 | 0.103 | 1.62 | 0.093 | 1.49 | + +Geometric means 1.69 (binary64; 2.39 at `a6722029`) and 1.71 (binary32 df32, 2 rounds). +Julia's times are the A40's or a little better (`rdw` 0.071 against 0.074): it is +host-bound there, where native's binary64 kernels take the H200's full rate (`h2_raman_6ps` +0.223 s against the A40's 1.04) and its sources replay as CUDA graphs. Binary32 gains +nothing on a full-rate card. From 51a153de1db20989c9f1dcaf12b65b4c12332d6c Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 17:00:00 +0000 Subject: [PATCH 101/107] Julia experiment: source evaluations as CUDA graphs, stage scalars on the device [skip ci] A source's passes (kernels, cuFFT, cuBLAS) are captured once their buffers and host values repeat, then replayed: host 4 us against 300-650 to launch them. The Kerr factor and plasma densities/preionisations are read from a device vector uploaded when they change, so a gradient replays one graph. Scans keep their AK workspaces (graph-safe). A40 binary64 0.95, binary32 df32 0.89 against launched sources (fields identical). A whole-trial graph was tried and reverted (1.60: order-dependent keys). SOLPROP_JULIA_TIMING=host times sections without synchronising; julia/profile.py takes SOLPROP_JULIA_ALLOCS. 59 CUDA tests pass. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 37 +++++++++++++ julia/ext/SolpropJuliaCUDAExt.jl | 5 ++ julia/profile.py | 38 ++++++++++++++ julia/src/SolpropJulia.jl | 4 +- julia/src/envelope.jl | 8 ++- julia/src/launch.jl | 50 +++++++++++++++++- julia/src/march.jl | 10 ++-- julia/src/modal.jl | 90 +++++++++++++++++++++++++++++++- julia/src/responses.jl | 30 ++++++----- 9 files changed, 247 insertions(+), 25 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 84edee418..61bd1dceb 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3309,3 +3309,40 @@ Julia's times are the A40's or a little better (`rdw` 0.071 against 0.074): it i host-bound there, where native's binary64 kernels take the H200's full rate (`h2_raman_6ps` 0.223 s against the A40's 1.04) and its sources replay as CUDA graphs. Binary32 gains nothing on a full-rate card. + +**NVIDIA A40, tiled transposes and kept reduction workspaces** (jl23, `8765b584` +against `67491bf9`'s engine, 3 rounds): binary64 `kerr_beam_192` 0.95, `rdw` 0.97, +`argon_blueshift` 1.02, `line` 1.05 (range 0.75–2.18), geometric mean 1.00; binary32 +df32 `kerr_beam_192` 0.92, `line` 0.95, 0.96 over the four. Fields identical. + +**Where the A40's host time goes** (`rdw`, 59 steps, `SOLPROP_JULIA_TIMING=host`, which +times sections without synchronising): the march's trials hold about half the window +(a trial about 0.43 ms of host: the plasma's passes 0.1, their projections' four cuBLAS +calls 0.07, synthesis and projection 0.05), and the statistics of 12 saved planes about +a third (2 ms a plane: the Poynting set 0.7, the population scan 0.4). A source launched +pass by pass against its captured CUDA graph's replay (`scripts/graph_probe.py`): `rdw` +962 against 386 us a source (host 415 against 4), `argon_blueshift` 848 against 267, +`h2_raman_6ps` 1201 against 663, results identical. + +**NVIDIA A40, source evaluations as CUDA graphs** (`graph_source!`; A/Bs against the +same tree with `SOLPROP_JULIA_GRAPH=0`, 3 rounds, fields identical). A source's passes, +kernels, cuFFT and cuBLAS alike, are captured once their buffers and host values have +repeated three times, then replayed. The stage's scalars (the Kerr factor and the plasma +channels' densities and preionisations) are read from one device vector, uploaded when +they change, so a gradient's every stage replays one graph; the taper (a product's +alpha) is still a captured value. Binary64 0.95 (`argon_blueshift` 0.86, `ctc_reduced` +and `h2_raman_6ps` 0.95, `rdw` 0.99, free space 0.96 and 0.99); binary32 df32 0.89 +(`argon_blueshift` 0.67, `ctc_reduced` 0.77, `h2_raman_6ps` 0.82, `rdw` 0.88; +`kerr_beam_192` 1.04, `line` 1.19 with a range of 0.68–1.45). With the scalars as +captured values instead (a gradient's keys never repeat) `rdw` was 1.21. Nsight on +`argon_blueshift` (binary64): the window 0.197 s against 0.155, the same 85 ms of +kernels, the launch API from 34 to 12 ms; `ctc_reduced` is now mostly the device's +(87 of 133 ms kernels, 40 ms of waiting in `cuEventSynchronize`). + +**A whole Adams trial as one graph** (predictor, source and corrector, the step and the +tables read from device memory; tried and reverted): 1.60 in binary64 (`rdw` 3.5, +radial 2.2, `argon_blueshift` 2.0). The predictor's and corrector's kernels take the +order and the number of defect rows as values, which the variable-order controller +changes from trial to trial, so a run captured and instantiated a graph for each +combination it met. Order-independent kernels (the order and rows read from the device, +loops to the largest) would be needed first. diff --git a/julia/ext/SolpropJuliaCUDAExt.jl b/julia/ext/SolpropJuliaCUDAExt.jl index 9d2b4d612..d7c0d54de 100644 --- a/julia/ext/SolpropJuliaCUDAExt.jl +++ b/julia/ext/SolpropJuliaCUDAExt.jl @@ -14,5 +14,10 @@ SolpropJulia.device_label(::CUDABackend) = "cuda: " * CUDA.name(CUDA.device()) SolpropJulia.long_transforms(::CUDABackend) = true # cuFFT's strided transverse planes are 3.4 times contiguous ones (`Transposed`). SolpropJulia.transposed_planes(::CUDABackend) = true +# A source's passes as a CUDA graph (`graph_source!`): stream capture records them, +# kernels, cuFFT and cuBLAS alike, on the task's stream. +SolpropJulia.graph_capable(::CUDABackend) = true +SolpropJulia.graph_capture(::CUDABackend, f) = CUDA.instantiate(CUDA.capture(f)) +SolpropJulia.graph_launch(exec::CUDA.CuGraphExec) = CUDA.launch(exec) end diff --git a/julia/profile.py b/julia/profile.py index db52c23b3..d975b6010 100644 --- a/julia/profile.py +++ b/julia/profile.py @@ -47,6 +47,14 @@ def profile(row: dict) -> None: Main.seval("Profile.clear(); Profile.start_timer()") jl.clear_timings() jl.clear_counts() + jl.clear_kernel_timings() + # SOLPROP_JULIA_ALLOCS=1: the host's allocations by where they are made (sampled; + # Profile.Allocs uses no signals, which the sampling profile's kill a CUDA process). + allocs = os.environ.get("SOLPROP_JULIA_ALLOCS") == "1" + if allocs: + from juliacall import Main # noqa: PLC0415 - after the runtime starts + + Main.seval("using Profile; Profile.Allocs.clear(); Profile.Allocs.start(sample_rate=0.002)") # SOLPROP_PYTHON_PROFILE=1: the host's Python time too (cProfile, by own time). python = os.environ.get("SOLPROP_PYTHON_PROFILE") == "1" if python: @@ -70,6 +78,29 @@ def profile(row: dict) -> None: "Profile.print(IOContext(stdout, :displaysize => (200, 220)); " "format=:flat, sortedby=:count, mincount=20, noisefloor=1)" ) + if allocs: + Main.seval("Profile.Allocs.stop()") + sys.stdout.write(str(Main.seval(r""" + let r = Profile.Allocs.fetch(), sites = Dict{String,Tuple{Int,Int}}() + for a in r.allocs + # The first frame in SolpropJulia, and the frame below it. + i = findfirst(f -> occursin("SolpropJulia", string(f.file)) || + occursin("/julia/src/", string(f.file)), a.stacktrace) + i === nothing && continue + f = a.stacktrace[i] + below = a.stacktrace[max(i - 1, 1)] + key = string(f.func, " ", basename(string(f.file)), ":", f.line, " <- ", + below.func) + n, b = get(sites, key, (0, 0)) + sites[key] = (n + 1, b + a.size) + end + total = length(r.allocs) + lines = ["sampled allocations: $total (x500 for the run)"] + for (k, (n, b)) in sort(collect(sites); by=x -> -x[2][1])[1:min(30, end)] + push!(lines, lpad(n, 7) * lpad(b, 11) * " " * k) + end + join(lines, "\n") + end""")) + "\n") times = jl.timings() total = sum(float(times[name]) for name in times) sys.stdout.write( @@ -83,6 +114,13 @@ def profile(row: dict) -> None: steps = max(int(record["accepted"]), 1) for name in sorted(counts): sys.stdout.write(f" {name:>18} {counts[name] / steps:8.1f} a step ({counts[name]})\n") + # SOLPROP_JULIA_KERNEL_TIMING=1: each GPU pass alone, by its body. + kernels = {str(k): list(v) for k, v in jl.kernel_timings().items()} + for name in sorted(kernels, key=lambda n: -float(kernels[n][1]))[:25]: + count, total, size = kernels[name] + sys.stdout.write( + f" {float(total) * 1e3:8.2f} ms {int(count):6d} x {int(size):9d} {name}\n" + ) engine.close() diff --git a/julia/src/SolpropJulia.jl b/julia/src/SolpropJulia.jl index 329c7861e..c005b1a74 100644 --- a/julia/src/SolpropJulia.jl +++ b/julia/src/SolpropJulia.jl @@ -64,8 +64,10 @@ real_type(engine) = real(eltype(engine.work.y)) # Read at load, not at precompilation: a constant would be baked into the cache. function __init__() - TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "1" + TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") in ("1", "host") + HOST_TIMING[] = get(ENV, "SOLPROP_JULIA_TIMING", "0") == "host" KERNEL_TIMING[] = get(ENV, "SOLPROP_JULIA_KERNEL_TIMING", "0") == "1" + GRAPHS[] = get(ENV, "SOLPROP_JULIA_GRAPH", "1") != "0" COUNT[] = get(ENV, "SOLPROP_JULIA_COUNT", "0") == "1" CHECK[] = get(ENV, "SOLPROP_JULIA_CHECK", "0") == "1" SAMPLE_PLASMA[] = get(ENV, "SOLPROP_JULIA_PLASMA", "columns") == "samples" diff --git a/julia/src/envelope.jl b/julia/src/envelope.jl index 4341abaa5..dc70c3f0d 100644 --- a/julia/src/envelope.jl +++ b/julia/src/envelope.jl @@ -30,6 +30,7 @@ function envelope_plasma_workspace(c, host, nt, chunk, nm, nn) nf = c.nf ( envelope=Val(true), channels=channels, fractions_all=fractions_all, peaks_all=peaks_all, + channel=1, coefficients=channels[1].coefficients, parameters=channels[1].parameters, constant_tail=channels[1].constant_tail, inverse_edges=channels[1].inverse_edges, inverse_tail=channels[1].inverse_tail, @@ -186,7 +187,7 @@ function envelope_exposure!(q, nodes, c, count) @inbounds exposure[t, n] = t == 1 ? none : muladd(half, rate[t-1, n], half * rate[t, n]) end tally!(:scan) - AK.accumulate!(+, @view(exposure[:, 1:count]); dims=1, init=none, backend=c.backend) + scan_columns!(@view(exposure[:, 1:count]), c, none) nothing end @@ -198,10 +199,13 @@ function envelope_current!(p, nodes, c, count) (; rate, exposure, gated, edge) = q T = typeof(q.dt) charge, potential = T(q.parameters[6]), T(q.parameters[7]) - density, initial = T(q.parameters[8]), T(q.parameters[9]) + k = q.channel + dens = stage_scalar(c, 2k, q.parameters[8]) + init = stage_scalar(c, 2k + 1, q.parameters[9]) none = zero(eltype(gated)) each!(c, size(nodes, 1), count) do t, n @inbounds begin + density, initial = stage_value(dens), stage_value(init) v, e = nodes[t, n], exposure[t, n] survival = (1 - initial) * exp(-e) fraction = initial + (1 - initial) * -expm1(-e) diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 5b029321d..fb37d8c2a 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -413,6 +413,17 @@ function gemm!(C, A, B, alpha, beta, c) C end +"""The running sums down each column of `v` (`AK.accumulate!`, `dims=1`), with the +scan's scratch kept on a GPU: a new one a call was a pool allocation, and inside a +captured source graph (`source!`) a freed buffer the replay would still read.""" +function scan_columns!(v, c, init) + oncpu(c) && return AK.accumulate!(+, v; dims=1, init=init, backend=c.backend) + workspace = get!(c.scratch, (:scan_workspace, eltype(v), size(v))) do + AK.workspace(AK.accumulate!, +, v; dims=1, init=init, backend=c.backend) + end + AK.accumulate!(+, v; dims=1, init=init, backend=c.backend, workspace=workspace) +end + """On a GPU, an operand that is a strided view (a range of a matrix's rows) copied into scratch: Metal.jl's product of one takes a generic kernel, about 240 us for 16384 x 36 x 8 on the M5 Max against 65 to 140 us copied first.""" @@ -485,13 +496,16 @@ const TIMING = Ref(false) const TIMES = Dict{Symbol,Float64}() # A device's timed sections wait for its queue at both ends (`synchronize_all`). const SYNCHRONIZE = Ref{Any}(() -> nothing) +# SOLPROP_JULIA_TIMING=host: the sections unsynchronised, so each measures the host's +# own time in it (enqueueing, host arithmetic, and any wait it makes itself). +const HOST_TIMING = Ref(false) macro section(name, ex) quote if TIMING[] - SYNCHRONIZE[]() + HOST_TIMING[] || SYNCHRONIZE[]() local started = time_ns() local result = $(esc(ex)) - SYNCHRONIZE[]() + HOST_TIMING[] || SYNCHRONIZE[]() TIMES[$name] = get(TIMES, $name, 0.0) + (time_ns() - started) * 1e-9 result else @@ -503,6 +517,38 @@ timings() = Dict(String(k) => v for (k, v) in TIMES) clear_timings() = (empty!(TIMES); nothing) timing_enabled() = TIMING[] +# --- Device graphs ------------------------------------------------------------------- + +"""`SOLPROP_JULIA_GRAPH=0` launches every source's passes one by one.""" +const GRAPHS = Ref(true) +"""Whether the device's extension captures and replays graphs (CUDA's does).""" +graph_capable(backend) = false +"""Capture `f`'s device work on the task's stream into an executable graph, or return +`nothing` where the device cannot.""" +graph_capture(backend, f) = nothing +graph_launch(exec) = throw(ArgumentError("no device graphs on this backend")) + +# --- Stage scalars in device memory --------------------------------------------------- + +"""A source's stage scalars on a device that replays graphs: the Kerr factor, then each +plasma channel's density and preionisation, in one device vector the kernels read +(`stage_value`), so that one captured graph serves every stage of a gradient. Slot 1 is +the factor; channel `k`'s density and preionisation are slots `2k` and `2k + 1`.""" +function stage_slots(c, slots) + get!(c.scratch, :stage_slots) do + (host=fill(NaN, slots), device=KA.allocate(c.backend, c.T, slots)) + end +end +"""A kernel's view of stage scalar `index` (times `scale`): the device vector's slot +where sources replay graphs, else the host's value.""" +function stage_scalar(c, index, host_value, scale=one(c.T)) + T = c.T + graph_values(c) || return T(host_value) * T(scale) + (values=c.scratch[:stage_slots].device, index=index, scale=T(scale)) +end +@inline stage_value(x::Number) = x +@inline stage_value(s::NamedTuple{(:values, :index, :scale)}) = @inbounds s.values[s.index] * s.scale + # --- Long binary64 transforms on a GPU, four-step ------------------------------------- """Whether the device's library takes long binary64 transforms slowly enough to split diff --git a/julia/src/march.jl b/julia/src/march.jl index 51a41cabd..ba2c72741 100644 --- a/julia/src/march.jl +++ b/julia/src/march.jl @@ -224,17 +224,17 @@ function march_start!(engine, m::MarchConfig, z) end function march_trial!(engine, m::MarchConfig, z, dz, s) - m.varying && configure_stages_at!(engine, z, stage_positions(m, z, dz)) + m.varying && @section :march_stages configure_stages_at!(engine, z, stage_positions(m, z, dz)) rate = m.compensated ? rate_at(m.rate, z + dz, true) : Float64[] - configure_adams_nodes!(engine, s.nodes, s.order, s.orders, s.rows, rate) - adams_trial!(engine, dz) + @section :march_tables configure_adams_nodes!(engine, s.nodes, s.order, s.orders, s.rows, rate) + @section :adams_trial adams_trial!(engine, dz) end """Adopt the held trial into row `free`, commit it; return its quadrature alarm. With a split collar the commit also forms the power the split finds (`split_power`).""" function march_accept!(engine, dz, free, split) - adams_accept!(engine, free) - commit!(engine, Float64(dz), split) + @section :adams_accept adams_accept!(engine, free) + @section :commit commit!(engine, Float64(dz), split) end # --- the run --------------------------------------------------------------------------- diff --git a/julia/src/modal.jl b/julia/src/modal.jl index dcd026a70..d893a7b2f 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -164,11 +164,97 @@ function scatter!(fine, lab, c) end end -"""Evaluate the translated source of `lab` into `work.source`.""" +"""Evaluate the translated source of `lab` into `work.source`: on a device that replays +graphs, the captured graph of this source when its host scalars are those it was +captured with (`graph_source!`), else each pass launched.""" function source!(engine, lab; quadrature=false) - c, w = engine.config, engine.work + c = engine.config + if graph_ready(c) + sync_stage_values!(engine) + return graph_source!(engine, lab, quadrature) + end + source_launched!(engine, lab, quadrature) +end + +"""Whether the source kernels read their stage scalars from device memory.""" +graph_values(c) = graph_ready(c) + +"""Upload the stage scalars (`stage_slots`) where they changed: once a stage along a +gradient, never in a uniform medium.""" +function sync_stage_values!(engine) + c, p = engine.config, engine.work.plasma + current = Float64[engine.factor] + if p !== nothing + for channel in p.channels + push!(current, channel.parameters[8], channel.parameters[9]) + end + end + held = stage_slots(c, length(current)) + held.host == current && return nothing + held.host .= current + tally!(:upload) + copyto!(held.device, c.T.(current)) + nothing +end + +function source_launched!(engine, lab, quadrature) + c = engine.config c.free && return source_free!(engine, lab) c.spectral && return source_spectral!(engine, lab, quadrature) + source_modal!(engine, lab, quadrature) +end + +"""Whether sources go through device graphs: a device whose extension captures them +(`graph_capture`), unless `SOLPROP_JULIA_GRAPH=0` or a timer that synchronises (which a +capture cannot contain) is on.""" +graph_ready(c) = !oncpu(c) && GRAPHS[] && graph_capable(c.backend) && + !(TIMING[] && !HOST_TIMING[]) && !KERNEL_TIMING[] + +"""The host values a captured source still holds: the taper (its products' alpha) and +whether the Kerr term is on. The stage's other scalars are device memory +(`stage_slots`), as are its prefactor and a rebuilt Raman kernel, all updated in +place, so a gradient's every stage replays one graph.""" +source_scalars(engine) = hash(engine.taper, hash(engine.factor != 0)) + +"""A source as a device graph: captured from the launched passes once the same buffers +and scalars have come round three times (by then every lazily made scratch, staging +buffer and plan exists, so the graph's pointers stay valid), then replayed. The replay +takes about 4 us of the host against 300 to 650 to launch the passes, and the device +runs them without the gaps between launches (`rdw` 386 against 962 us a source on an +A40, the same bits). A tapered guide, whose taper changes at every stage, keeps launching +its passes.""" +graph_source!(engine, lab, quadrature) = + replay_or_capture!(() -> source_launched!(engine, lab, quadrature), engine, + (:source_graph, objectid(lab), quadrature, source_scalars(engine))) + +"""Run `body`'s device work as a captured graph once `key` (the buffers, the shapes, the +host values the work holds) has come round three times, and replay it after; before, +or where the device cannot capture, run it as written. `body` evaluates `sources` +sources, which the replay counts.""" +function replay_or_capture!(body, engine, key; sources=1) + c = engine.config + graphs = c.scratch + exec = get(graphs, key, nothing) + if exec === nothing + seen = get(graphs, (:seen, key), 0) + 1 + # (A varying medium's keys never repeat: stop counting them past a bound.) + length(graphs) < 4096 && (graphs[(:seen, key)] = seen) + seen < 3 && return body() + calls = engine.calls + exec = graph_capture(c.backend, body) + engine.calls = calls + exec === nothing && return body() + graphs[key] = exec + tally!(:graph_capture) + end + tally!(:graph_replay) + graph_launch(exec) + engine.calls += sources + nothing +end + +function source_modal!(engine, lab, quadrature) + c, w = engine.config, engine.work nm = size(lab, 2) @section :scatter scatter!(w.fine, lab, c) raman = w.raman diff --git a/julia/src/responses.jl b/julia/src/responses.jl index a82762eae..6e845d4c0 100644 --- a/julia/src/responses.jl +++ b/julia/src/responses.jl @@ -16,17 +16,17 @@ present, multiplies the field by its convolved drive (`raman_drive!`). function nonlinear_nodes!(nodes, values, c, factor, raman, count) window, a = c.window, c.analytic_factor T = eltype(window) - f = T(factor) + g = stage_scalar(c, 1, factor) if raman === nothing each!(c, size(nodes, 1), count) do t, m - @inbounds nodes[t, m] = polarization(values[t, m], f, a) * window[t] + @inbounds nodes[t, m] = polarization(values[t, m], stage_value(g), a) * window[t] end else drive, r = raman.products ? raman.nodal : raman.drive, T(raman.factor) each!(c, size(nodes, 1), count) do t, m @inbounds begin v = nodes[t, m] - nodes[t, m] = muladd(r * v, drive[t, m], polarization(values[t, m], f, a)) * window[t] + nodes[t, m] = muladd(r * v, drive[t, m], polarization(values[t, m], stage_value(g), a)) * window[t] end end end @@ -35,19 +35,19 @@ end function nonlinear_envelope!(nodes, c, factor, raman, count) window = c.window T = eltype(window) - f = T(factor) * c.analytic_factor + g = stage_scalar(c, 1, factor, c.analytic_factor) r = raman === nothing ? zero(T) : T(raman.factor) drive = raman === nothing ? nodes : raman.drive live = raman !== nothing # The third harmonic's term, factor h exp(2 i w0 t) E^2 E, where one is compiled. - h, carrier = T(factor) * c.harmonic, c.carrier - harmonic = !iszero(h) + hg, carrier = stage_scalar(c, 1, factor, c.harmonic), c.carrier + harmonic = !iszero(c.harmonic) each!(c, size(nodes, 1), count) do t, m @inbounds begin v = nodes[t, m] - response = f * abs2(v) * v + response = stage_value(g) * abs2(v) * v if harmonic - response += h * carrier[t] * (v * v) * v + response += stage_value(hg) * carrier[t] * (v * v) * v end if live response = muladd(r * v, real(drive[t, m]), response) @@ -92,7 +92,7 @@ function plasma_workspace(c, host, nt, chunk, nm, nn) parameters=host.array("plasma_parameters" * suffix(k), Float64)) for k in 1:count] fractions_all, peaks_all = dzeros(c, T, nn, count), dzeros(c, T, nn, count) ( - channels=channels, fractions_all=fractions_all, peaks_all=peaks_all, + channels=channels, fractions_all=fractions_all, peaks_all=peaks_all, channel=1, coefficients=channels[1].coefficients, # Field range, rate cap, log-table origin and step, charge-mass ratio and # ionisation potential; density and preionisation are a stage's (stages.jl). @@ -357,7 +357,8 @@ function each_channel(f::F, p) where {F} for (k, channel) in enumerate(p.channels) # (The channel's every table: an envelope's carries its precise rate's tails.) q = k == 1 ? p : - merge(p, channel, (fractions=view(p.fractions_all, :, k), peaks=view(p.peaks_all, :, k))) + merge(p, channel, (fractions=view(p.fractions_all, :, k), peaks=view(p.peaks_all, :, k), + channel=k)) f(q, k > 1) end end @@ -380,7 +381,7 @@ function integrate_samples!(out, values, taps, dt, c, count) half * (filtered(values, t, n, taps) + filtered(values, t - 1, n, taps)) end tally!(:scan) - AK.accumulate!(+, @view(out[:, 1:count]); dims=1, init=zero(dt), backend=c.backend) + scan_columns!(@view(out[:, 1:count]), c, zero(dt)) nothing end @@ -390,7 +391,9 @@ function plasma_samples!(p, nodes, c, count, add=false) window, floor = c.window, p.floor args = rate_arguments(p) charge, potential = T(p.parameters[6]), T(p.parameters[7]) - density, initial = T(p.parameters[8]), T(p.parameters[9]) + k = p.channel + dens = stage_scalar(c, 2k, p.parameters[8]) + init = stage_scalar(c, 2k + 1, p.parameters[9]) nt, none = size(nodes, 1), zero(T) each!(c, nt, count) do t, n @inbounds rate[t, n] = scaled_rate(nodes[t, n], args...) @@ -398,6 +401,7 @@ function plasma_samples!(p, nodes, c, count, add=false) integrate_samples!(fraction, rate, taps, dt, c, count) each!(c, nt, count) do t, n @inbounds begin + initial = stage_value(init) exposure = floor ? max(fraction[t, n], none) : fraction[t, n] value = 1 - (1 - initial) * exp(-exposure) fraction[t, n] = value @@ -411,7 +415,7 @@ function plasma_samples!(p, nodes, c, count, add=false) squared = field * field loss = rate[t, n] > 0 && squared > 0 ? (potential * rate[t, n] * (1 - fraction[t, n]) / squared) * field : none - total = density * (current[t, n] + loss) + total = stage_value(dens) * (current[t, n] + loss) if add gated[t, n] += window[t] * total edge[t, n] += derivative[t] * total From e3b07264bbcf76268155a9e4690d7c279a1bf54e Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 19:23:25 +0000 Subject: [PATCH 102/107] Julia experiment: large states copied directly to and from the host [skip ci] A state above 16 MB goes from the device straight into the reader's buffer (a binary32 one through a kept staging buffer), and a binary64 load straight up: the held copy, a conversion and the reader's copy were three passes and two 226 MB allocations on kerr_beam_192 (0.29 of its 0.42 s window). A40 kerr_beam_192 0.56 binary64, 0.60 binary32; small states unchanged. The A40 against native at 51a153de: 1.15 binary64, 0.79 binary32 df32. 59 CUDA tests pass. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 27 +++++++++++++++++++++ julia/STATUS.md | 55 ++++++++++++++++++++++++++++-------------- julia/src/observe.jl | 39 +++++++++++++++++++++++++----- 3 files changed, 97 insertions(+), 24 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 61bd1dceb..54da7a047 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3346,3 +3346,30 @@ order and the number of defect rows as values, which the variable-order controll changes from trial to trial, so a run captured and instantiated a graph for each combination it met. Order-independent kernels (the order and rows read from the device, loops to the largest) would be needed first. + +**NVIDIA A40 against native at `51a153de`** (source graphs; jl31, 3 rounds binary64, 2 +binary32): + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.053 | 0.073 | 1.38 | 0.066 | 1.22 | +| `argon_blueshift` | 0.117 | 0.143 | 1.23 | 0.100 | 0.86 | +| `h2_raman_6ps` | 1.041 | 0.624 | 0.60 | 0.258 | 0.25 | +| `ctc_reduced` | 0.206 | 0.124 | 0.60 | 0.079 | 0.38 | +| `radial_filament_256` | 0.167 | 0.240 | 1.42 | 0.127 | 0.73 | +| `kerr_beam_192` | 0.187 | 0.432 | 2.44 | 0.468 | 2.49 | +| `line` | 0.095 | 0.120 | 1.28 | 0.103 | 1.05 | + +Geometric means 1.15 (binary64) and 0.79 (binary32 df32). `kerr_beam_192`'s window is +one RK4IP step on a 226 MB state: of its 0.42 s, the copy of the saved plane's field to +the host took 0.29 (the step's device work waited for, then three host passes and two +allocations), and the initial load 0.065. + +**NVIDIA A40, direct state copies** (a state above 16 MB copied from the device straight +into the reader's buffer, and a binary64 load copied straight up; a smaller one held +once a state as before; jl33/jl34 against `51a153de`, 3 rounds): `kerr_beam_192` 0.56 +(binary64, 0.416 to 0.232 s) and 0.60 (binary32 df32), `rdw` 1.01 and 1.01, radial 1.09 +and 0.90 (ranges 1.08–1.25 and 0.72–1.15), `line` 0.98 and 1.02. Against native's 0.187 +s, `kerr_beam_192` is about 1.24 in binary64. A first version that also changed the small +states' copy to a broadcast cost `rdw` 1.12: the new method compiled inside the timed +window (the compile trace lists the old operations). diff --git a/julia/STATUS.md b/julia/STATUS.md index 355ec2d3f..4048ffeeb 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -275,6 +275,35 @@ Cartesian transverse transform through a transverse-first copy (`Transposed`) gi 0.92 on `kerr_beam_192` and 0.89 on `line` on the A40 (binary64), and 1.10 and 1.09 on Metal, so it is CUDA's only. +## 2026-11-08, the GPU host + +On the A40, in binary64, native against Julia went from 1.80 in the morning to 1.15 at +`51a153de` (binary32 df32 from 1.56 to 0.79: Julia faster in five of seven cases), and +the H200 at `67491bf9` is 1.69 (2.39 before). In order of what each change bought on the A40 (the ledger has every row): +- **Kernel bodies inlined** (`@inline f(t, m)` in the GPU kernel): left to the + inliner, a body was a device call per sample with its arguments in local memory, + 9 times slower in binary64 and 20 in binary32. 0.70 / 0.62 over the seven cases. + Metal's compiler inlines them itself (1.01). +- **Source graphs** (`graph_source!`): a source's passes, kernels, cuFFT and cuBLAS, + captured once and replayed (host 4 us against 300 to 650), its stage scalars read + from a device vector so that a gradient replays one graph. 0.95 / 0.89. +- **Four-step long FFTs** (`LongFFT`): cuFFT runs a binary64 transform of a few + thousand points as one block (96 us at 5120); split, 23 us. 0.99 overall, 0.92 to + 0.94 on the plasma capillaries. +- **Transverse-first copies** of the Cartesian planes, tiled: 0.89 to 0.95 on the + free-space cases (CUDA only; Metal's strided transforms are faster as they are). +- **Direct state copies**: a large state straight between the device and the reader's + buffer (three host passes and two allocations were 0.29 s of `kerr_beam_192`'s + 0.42 s window). `kerr_beam_192` 0.56, about 1.24 against native. + +What is left on a full-rate card (the H200) is the host: Julia's times there are the +A40's, where native's halve. Per Adams step the host still makes about 11 launches +outside the graph (predictor, corrector, commit), the trial's table upload and the +norm's readback, the step controller's true dependency; per saved plane the statistics +take about 2 ms (`rdw`'s 12 planes in a 2 % window are a third of it). A whole-trial +graph was tried and reverted: its kernels take the Adams order as a value, so a +variable-order run captured a graph for each order it met (1.60). + ## Next steps Roughly in order of what they would tell. @@ -283,24 +312,14 @@ Roughly in order of what they would tell. Julia's host time about a fifth); the statistics' readbacks are fixed (observe 4.7 of 195 ms). What is left is the source: fusing `source_free!`'s and the DOPRI stage's elementwise passes would save perhaps 5 ms. -2. **The A40's remaining kernels** after the FFT split: the Adams predictor (0.28 ms - a trial on `rdw`, its phi functions spilling) and the mode-averaged elementwise - kernels at 0.1 ms each over a few thousand elements (latency: too few threads, - long binary64 chains). -3. **The A40 against native (1.81 binary64, 1.48 binary32 df32).** Fair profiles - need `nsys --cuda-graph-trace=node` (native's sources run in CUDA graphs). What is - left: - - Host time between launches (the march and the trial tables while the device - idles), about twice native's. Kernel launches are cheap (2.5 us), cuFFT 3 us, - cuBLAS 14 us, a readback 31 us (DMOG A40, `scripts/launch_cost.jl`). - - The Adams predictor kernel, 0.28 ms a step on `rdw`: its phi functions spill to - local memory (120 to 230 bytes; `scripts/phi_regs.jl`). - - Cartesian transforms: a 2D FFT over the trailing dimensions of the frequency-first - state is 3.4 times one over contiguous leading dimensions (16.2 against 4.8 ms at - 512 x 192 x 192). A transverse-first layout for free space is the fix. - - radial's CUTLASS binary64 GEMMs (the A40 has no binary64 tensor cores). - - CUDA graph capture would need the kernels to read their changing scalars from - device memory, as native's do. +2. **The GPU host, continued.** An order-independent Adams trial (the order and the + defect rows read from the device, loops to the largest), so that one graph serves + a run; the predictor's and corrector's passes fused as native's are; the plane + statistics' readbacks folded. Then the H200 and an MI325X again. +3. **The A40's remaining kernels:** the Adams predictor (0.1 to 0.28 ms a trial, its + phi functions spilling, latency-bound on a mode-averaged state's few thousand + elements) and radial's CUTLASS binary64 GEMMs (the A40 has no binary64 tensor + cores). 4. **Metal start latency** (about 28 s of kernel compilation): a recorded trace or a system image. 5. **Binary32 on x86**, two to three times binary64 on the Xeon, not subnormals. diff --git a/julia/src/observe.jl b/julia/src/observe.jl index 840654b2b..52384ebc7 100644 --- a/julia/src/observe.jl +++ b/julia/src/observe.jl @@ -30,31 +30,58 @@ function copy_state!(engine, buffer) @section :observe begin c, w = engine.config, engine.work target = host_wrap(buffer, ComplexF64) + scale = engine.config.scale if oncpu(c) copy_between!(target, w.y, c) + scale == 1 || (target .*= scale) + elseif sizeof(w.y) > LARGE_STATE + # A large state straight into the reader's buffer, one pass (a binary32 one + # through a kept staging buffer, converted and scaled in one more): the held + # copy, a conversion and the reader's copy were three passes and two fresh + # allocations over a Cartesian state's 226 MB. + if eltype(w.y) == ComplexF64 + copyto!(target, w.y) + scale == 1 || (target .*= scale) + else + staging = get!(() -> similar(Array{eltype(w.y)}, size(w.y)), c.scratch, :host_state) + copyto!(staging, w.y) + target .= scale .* staging + end else - # One copy from the device a state, however many readers ask (`version`). + # A small one copied once a state, however many readers ask (`version`): + # each copy is a wait on the device (about 0.2 ms on Metal). held = w.held_state if held[] === nothing || first(held[]) != engine.version held[] = (engine.version, Matrix{ComplexF64}(Array(w.y))) end + # (The operations of the compile trace: a new broadcast here compiled inside + # a timed window, about 8 ms on `rdw`.) copyto!(target, last(held[])) + scale == 1 || (target .*= scale) end - scale = engine.config.scale - scale == 1 || (target .*= scale) end nothing end +"""A state above this size (bytes) is copied to each reader directly, not held.""" +const LARGE_STATE = 16 * 2^20 """Load a host state given as its (n_omega, n_modes) column-major view.""" function load!(engine, input) y = engine.work.y source = host_wrap(input, ComplexF64) inverse = inv(engine.config.scale) - if oncpu(engine.config) && eltype(y) == ComplexF64 && inverse == 1 - copy_between!(y, source, engine.config) + c = engine.config + if oncpu(c) && eltype(y) == ComplexF64 && inverse == 1 + copy_between!(y, source, c) + elseif eltype(y) == ComplexF64 && inverse == 1 + # Straight to the device, one pass. + copyto!(y, source) else - copyto!(y, upload(engine.config, eltype(y).(source .* inverse))) + # Converted and scaled into a kept host buffer, then one copy up: the scaled + # copy, the conversion and a fresh device array were three passes. + staging = get!(() -> similar(Array{eltype(y)}, size(y)), c.scratch, :host_state) + staging .= source .* inverse + copyto!(y, staging) end reset!(engine) end From 1e609d68c2aa09e2f1b187cbf627a79826f5dd2a Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 21:50:49 +0000 Subject: [PATCH 103/107] Ledger: the order-independent Adams trial graph, tried and reverted [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 54da7a047..2e63b1ec5 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3373,3 +3373,12 @@ and 0.90 (ranges 1.08–1.25 and 0.72–1.15), `line` 0.98 and 1.02. Against nat s, `kerr_beam_192` is about 1.24 in binary64. A first version that also changed the small states' copy to a broadcast cost `rdw` 1.12: the new method compiled inside the timed window (the compile trace lists the old operations). + +**An order-independent Adams trial graph** (tried and reverted): the predictor and +corrector compiled at the largest width, reading the trial's order, width and defect +rows from device memory, so that one graph serves a run (`rdw` captured once and +replayed every trial; launches a step 14.3 to 11.2, `argon_blueshift` 7.5 to 4.4). +Against `e3b07264` (jl35, 3 rounds): binary64 1.03 (`rdw` 1.45, `h2_raman_6ps` 1.09, +`argon_blueshift` 0.97, `ctc_reduced` 1.00), binary32 df32 1.10 (`rdw` 1.70). The +predictor's phi functions formed to the largest width cost more than the three +launches saved, and the host time left is not in those launches. From 1b17fc75edf2a3e207093c6869c71e1fd8a2941f Mon Sep 17 00:00:00 2001 From: John Travers Date: Sun, 8 Nov 2026 23:58:12 +0000 Subject: [PATCH 104/107] Julia experiment: fused device reductions; kept staging for per-trial uploads [skip ci] Reductions form each element inside the reduction's first pass and finish on the device (two kernels, one value read back), where AK's reduction finished its last stage on the host: about 50 us of idle device a step on an A40. The stage tables' and scalars' host staging is kept (no per-trial arrays; pageable on purpose). Nsight step timelines against native (scripts/step_timeline.py) in the ledger. A40 binary64 0.96 against e3b07264; 59 CPU and 59 CUDA tests pass. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 19 +++++++++ julia/profile.py | 5 ++- julia/src/launch.jl | 92 ++++++++++++++++++++++++++++++++---------- julia/src/modal.jl | 3 +- julia/src/stages.jl | 18 +++++++-- 5 files changed, 110 insertions(+), 27 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 2e63b1ec5..a052da7ab 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3382,3 +3382,22 @@ Against `e3b07264` (jl35, 3 rounds): binary64 1.03 (`rdw` 1.45, `h2_raman_6ps` 1 `argon_blueshift` 0.97, `ctc_reduced` 1.00), binary32 df32 1.10 (`rdw` 1.70). The predictor's phi functions formed to the largest width cost more than the three launches saved, and the host time left is not in those launches. + +**Where a step's time goes, native against Julia** (A40, binary64, Nsight with graph +nodes, `scripts/step_timeline.py`: each step between two graph launches, median over the +window). `argon_blueshift`: native 466 us a step, the device busy 377, idle 88, 5 +launches and 1 copy; Julia at `e3b07264` 539 us, busy 375, idle 164, 8 launches and 3 +copies. `rdw`: native 629 (busy 561, idle 68), Julia 817 (busy 636, idle 180). The +device's work is the same; the difference is idle time. Julia's largest gap was after +the corrector's reduction (about 50 us a step: AK's reduction finished its last stage on +the host); then the host's preparation after the norm's readback (30 us against native's +20), the source graph's launch (`cuGraphLaunch` about 56 us of host), and the saved +planes (about 1.8 ms of idle device a plane against 1.25; in Python's profile the time +is inside the Julia calls, each with its own wait, not in numpy). + +**NVIDIA A40, fused device reductions** (`fused_reduce!`: each element formed inside the +reduction's first pass, the blocks' partials by a second, the one value read back; +`reduce_each` and `sum_device!` through it; jl37 against `e3b07264`, 3 rounds): binary64 +0.96 (`rdw` 0.99, `argon_blueshift` 0.99, `ctc_reduced` 0.99, `h2_raman_6ps` 0.98, +radial 1.05; `line` and `kerr_beam_192` noisy). In Nsight `argon_blueshift`'s step went +from 539 to 509 us, its idle from 164 to 136 (native 88). diff --git a/julia/profile.py b/julia/profile.py index d975b6010..f8d13bbb8 100644 --- a/julia/profile.py +++ b/julia/profile.py @@ -71,7 +71,10 @@ def profile(row: dict) -> None: ) if python: profiler.disable() - pstats.Stats(profiler, stream=sys.stdout).sort_stats("cumulative").print_stats("julia/_|integrators|_march", 30) + # SOLPROP_PYTHON_PROFILE_SORT / _FILTER: the order and the file filter (a regex). + order = os.environ.get("SOLPROP_PYTHON_PROFILE_SORT", "cumulative") + pattern = os.environ.get("SOLPROP_PYTHON_PROFILE_FILTER", "julia/_|integrators|_march") + pstats.Stats(profiler, stream=sys.stdout).sort_stats(order).print_stats(pattern, 40) if sampling: Main.seval("Profile.stop_timer()") Main.seval( diff --git a/julia/src/launch.jl b/julia/src/launch.jl index fb37d8c2a..0476dd54b 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -238,22 +238,74 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=fa return foldl(op, partials; init=neutral) end tally!(:readback) - # The bodies run as an elementwise kernel into scratch, inlined (`each_kernel!`), and - # only the values reduce: inside AK's reduction the body was a device call per - # element, and a heavy one got several elements a thread (six blocks for rdw's - # 10244, its predictor 539 us a trial on an A40). - scratch = SolpropJulia.scratch(c, heavy ? :heavy : :reduce, typeof(neutral), nt * nm) - each!(c, nt, nm) do t, m - @inbounds scratch[t+(m-1)*nt] = @inline f(t, m) + out = scratch(c, :reduce_out, typeof(neutral), 1) + fused_reduce!(f, op, out, neutral, c, nt, nm) + @inbounds Array(out)[1] +end + +"""Fold `op` over `f(t, m)` at every sample into the device's `out[1]`, from `neutral`: +each element formed inside the reduction's first pass (one a thread up to 262144, then +strided), each block reduced in local memory, the blocks' partials reduced by one more +block. Nothing comes back to the host and nothing is allocated. Native's reductions are +shaped so; Julia's were an elementwise pass into scratch, then AK's reduction, which +finished its last stage on the host: about 50 us of an idle device a step on an A40 +(Nsight, `scripts/step_timeline.py`). The order is the tree's (SEP 25 bounds it).""" +function fused_reduce!(f::F, op::O, out, neutral, c, nt::Integer, nm::Integer) where {F,O} + CHECK[] && check_body(F) + n = Int(nt) * Int(nm) + blocks = clamp(cld(n, REDUCE_BLOCK), 1, REDUCE_PARTIALS) + partials = scratch(c, :reduce_partials, typeof(neutral), REDUCE_PARTIALS) + tally!(:launch, 2) + reduce_body!(c.backend, REDUCE_BLOCK)(partials, f, op, neutral, Int(nt), n; ndrange=blocks * REDUCE_BLOCK) + reduce_partials!(c.backend, REDUCE_BLOCK)(out, partials, op, neutral, blocks; ndrange=REDUCE_BLOCK) + out +end +const REDUCE_BLOCK = 256 +const REDUCE_PARTIALS = 1024 +KA.@kernel inbounds = true function reduce_body!(partials, f, op, neutral, nt, n) + local_index = KA.@index(Local, Linear) + group = KA.@index(Group, Linear) + groups = KA.@ndrange()[1] ÷ REDUCE_BLOCK + shared = KA.@localmem eltype(partials) (REDUCE_BLOCK,) + value = neutral + i = (group - 1) * REDUCE_BLOCK + local_index + while i <= n + m = (i - 1) ÷ nt + 1 + value = op(value, @inline f(i - (m - 1) * nt, m)) + i += groups * REDUCE_BLOCK + end + shared[local_index] = value + KA.@synchronize + width = REDUCE_BLOCK ÷ 2 + while width > 0 + if local_index <= width + shared[local_index] = op(shared[local_index], shared[local_index+width]) + end + KA.@synchronize + width ÷= 2 + end + local_index == 1 && (partials[group] = shared[1]) +end +KA.@kernel inbounds = true function reduce_partials!(out, @Const(partials), op, neutral, count) + local_index = KA.@index(Local, Linear) + shared = KA.@localmem eltype(out) (REDUCE_BLOCK,) + value = neutral + i = local_index + while i <= count + value = op(value, partials[i]) + i += REDUCE_BLOCK end - # The reduction's own scratch, kept (AK's `workspace`): a new partials buffer a call - # was an allocation from the pool and its copies, dozens a step. - workspace = get!(c.scratch, (:reduce_workspace, typeof(op), typeof(neutral), nt * nm)) do - AK.workspace(AK.mapreduce, identity, op, scratch; backend=c.backend, init=neutral, - neutral=neutral) + shared[local_index] = value + KA.@synchronize + width = REDUCE_BLOCK ÷ 2 + while width > 0 + if local_index <= width + shared[local_index] = op(shared[local_index], shared[local_index+width]) + end + KA.@synchronize + width ÷= 2 end - AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, neutral=neutral, - workspace=workspace) + local_index == 1 && (out[1] = shared[1]) end """The sum of `f(t, m)` over every sample into `out[1]`, which the next kernel reads: on a @@ -265,13 +317,7 @@ function sum_device!(f::F, out, c, nt::Integer, nm::Integer; heavy=false) where @inbounds out[1] = reduce_each(f, +, zero(eltype(out)), c, nt, nm; heavy=heavy) return out end - terms = SolpropJulia.scratch(c, :sum_terms, eltype(out), 1, nt * nm) - each!(c, nt, nm) do t, m - @inbounds terms[1, t+(m-1)*nt] = @inline f(t, m) - end - tally!(:launch) - sum!(reshape(out, 1, 1), terms) - out + fused_reduce!(f, +, out, zero(eltype(out)), c, nt, nm) end # FFTW's planner measures every plan unless SOLPROP_FFTW_PLAN says otherwise. Unlike @@ -536,7 +582,9 @@ plasma channel's density and preionisation, in one device vector the kernels rea the factor; channel `k`'s density and preionisation are slots `2k` and `2k + 1`.""" function stage_slots(c, slots) get!(c.scratch, :stage_slots) do - (host=fill(NaN, slots), device=KA.allocate(c.backend, c.T, slots)) + # (The staging is pageable on purpose: the driver copies it at once, so the + # next stage may rewrite it; a pinned copy would only be queued.) + (host=fill(NaN, slots), device=KA.allocate(c.backend, c.T, slots), staging=zeros(c.T, slots)) end end """A kernel's view of stage scalar `index` (times `scale`): the device vector's slot diff --git a/julia/src/modal.jl b/julia/src/modal.jl index d893a7b2f..3d2abf5ee 100644 --- a/julia/src/modal.jl +++ b/julia/src/modal.jl @@ -193,7 +193,8 @@ function sync_stage_values!(engine) held.host == current && return nothing held.host .= current tally!(:upload) - copyto!(held.device, c.T.(current)) + held.staging .= current + copyto!(held.device, held.staging) nothing end diff --git a/julia/src/stages.jl b/julia/src/stages.jl index f22d270da..4afa146c0 100644 --- a/julia/src/stages.jl +++ b/julia/src/stages.jl @@ -15,6 +15,10 @@ function path_workspace(c, host) delta=zeros(size(phi, 3), stages), weights=zeros(size(pre, 3), stages), delta_device=dzeros(c, wide_eltype(c), size(phi, 3), stages), weights_device=dzeros(c, c.T, size(pre, 3), stages), + # Their host staging, kept: a converted copy a trial was two fresh arrays. (Pageable + # on purpose: the driver copies it at once, so the next trial may rewrite it.) + delta_staging=fill(c.wide, size(phi, 3), stages), + weights_staging=zeros(c.T, size(pre, 3), stages), # Kerr, the first channel's density and preionisation, the taper, then each later # channel's density and preionisation. material=[zeros(3, stages); ones(1, stages); @@ -31,9 +35,17 @@ function configure_stages!(engine, delta, weights, material) copyto!(p.delta, Matrix{Float64}(delta)) copyto!(p.weights, Matrix{Float64}(weights)) copyto!(p.material, Matrix{Float64}(material)) - p.delta_device isa Array || tally!(:upload, 2) - copyto!(p.delta_device, widen_host(wide_eltype(engine.config), p.delta)) - copyto!(p.weights_device, real_type(engine).(p.weights)) + if p.delta_device isa Array + copyto!(p.delta_device, widen_host(wide_eltype(engine.config), p.delta)) + copyto!(p.weights_device, real_type(engine).(p.weights)) + else + tally!(:upload, 2) + W, T = wide_eltype(engine.config), real_type(engine) + p.delta_staging .= W.(p.delta) + p.weights_staging .= T.(p.weights) + copyto!(p.delta_device, p.delta_staging) + copyto!(p.weights_device, p.weights_staging) + end material_stage!(engine, 1) nothing end From e8921b45dc1f75a128e65b9da108dbfdc71f2c70 Mon Sep 17 00:00:00 2001 From: John Travers Date: Mon, 9 Nov 2026 03:18:43 +0000 Subject: [PATCH 105/107] Julia experiment: AK reductions restored; MI300X and step timelines recorded [skip ci] The fused device reductions of 1b17fc75 cost ctc_reduced 10-20 % in binary32 on an A40 (and a hybrid did too) without a reliable gain over whole windows, so AK's reductions with kept workspaces return; the per-trial host staging stays. An AMD MI300X (ROCm, no graphs): native against Julia 1.28 binary64, 1.48 binary32 df32. STATUS next steps updated. 59 CPU and 59 CUDA tests pass. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 31 +++++++++++++++ julia/STATUS.md | 16 +++++--- julia/src/launch.jl | 88 ++++++++++-------------------------------- 3 files changed, 63 insertions(+), 72 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index a052da7ab..1b66a82e6 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3401,3 +3401,34 @@ reduction's first pass, the blocks' partials by a second, the one value read bac 0.96 (`rdw` 0.99, `argon_blueshift` 0.99, `ctc_reduced` 0.99, `h2_raman_6ps` 0.98, radial 1.05; `line` and `kerr_beam_192` noisy). In Nsight `argon_blueshift`'s step went from 539 to 509 us, its idle from 164 to 136 (native 88). + +**AMD Instinct MI300X** (DigitalOcean, atl1, a VF, ROCm 10.0 in the image, gfx942, 20 +host cores) at `1b17fc75`: native's HIP build (4 minutes) against `julia` on AMDGPU.jl, +`--device`, 2 % windows; the Julia GPU tests passed there (33 selected). Julia on ROCm +has the inlined bodies, the fused reductions and the direct copies, but not the graphs +(CUDA's only so far). + +| case | native / s | julia / s | ratio | julia32 df32 / s | ratio | +|---|---:|---:|---:|---:|---:| +| `rdw` | 0.036 | 0.058 | 1.62 | 0.111 | 3.08 | +| `argon_blueshift` | 0.063 | 0.106 | 1.68 | 0.101 | 1.56 | +| `h2_raman_6ps` | 0.241 | 0.263 | 1.09 | 0.254 | 1.06 | +| `ctc_reduced` | 0.068 | 0.063 | 0.92 | 0.083 | 1.20 | +| `radial_filament_256` | 0.054 | 0.095 | 1.75 | 0.085 | 1.58 | +| `kerr_beam_192` | 0.117 | 0.104 | 0.89 | 0.141 | 1.26 | +| `line` | 0.062 | 0.080 | 1.30 | 0.080 | 1.29 | + +Geometric means 1.28 (binary64; the MI325X's was 2.48 at `a6722029`) and 1.48 (binary32 +df32, 2 rounds). On a card with binary64 at full rate the double-float wide type costs +more than binary64 itself (`rdw` 0.111 s against 0.058), so binary32 with df32 belongs to +cards without fast binary64 (an A40, an Apple GPU). + +**Fused device reductions, reverted.** Binary32 df32 against `e3b07264` (jl37, jl41): +1.15 over the seven cases in jl37, and in a focused rerun `ctc_reduced` 1.11 (1.06–1.14), +`argon_blueshift` 0.98, `h2_raman_6ps` 0.96. A hybrid (heavy bodies' values into scratch +first, then the two-pass device reduction; light ones fused) measured binary64 1.01 and +binary32 0.98, `ctc_reduced` still 1.20 in binary32 (jl42). The kernel timer, without +graphs, shows no slower kernel on `ctc_reduced` (0.149 against 0.144 s), so the loss is in +how the reductions sit beside the replayed graphs, not found. Neither version measures +better over whole windows, so AK's reductions (with kept workspaces) stay; the per-trial +host staging kept from `1b17fc75` is unchanged. diff --git a/julia/STATUS.md b/julia/STATUS.md index 4048ffeeb..bae655e30 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -279,7 +279,8 @@ on Metal, so it is CUDA's only. On the A40, in binary64, native against Julia went from 1.80 in the morning to 1.15 at `51a153de` (binary32 df32 from 1.56 to 0.79: Julia faster in five of seven cases), and -the H200 at `67491bf9` is 1.69 (2.39 before). In order of what each change bought on the A40 (the ledger has every row): +the H200 at `67491bf9` is 1.69 (2.39 before), and an AMD MI300X at `1b17fc75` 1.28 (the +MI325X's was 2.48), without graphs, which are CUDA's only so far. In order of what each change bought on the A40 (the ledger has every row): - **Kernel bodies inlined** (`@inline f(t, m)` in the GPU kernel): left to the inliner, a body was a device call per sample with its arguments in local memory, 9 times slower in binary64 and 20 in binary32. 0.70 / 0.62 over the seven cases. @@ -312,10 +313,15 @@ Roughly in order of what they would tell. Julia's host time about a fifth); the statistics' readbacks are fixed (observe 4.7 of 195 ms). What is left is the source: fusing `source_free!`'s and the DOPRI stage's elementwise passes would save perhaps 5 ms. -2. **The GPU host, continued.** An order-independent Adams trial (the order and the - defect rows read from the device, loops to the largest), so that one graph serves - a run; the predictor's and corrector's passes fused as native's are; the plane - statistics' readbacks folded. Then the H200 and an MI325X again. +2. **The GPU host, continued.** Nsight per-step timelines against native + (`scripts/step_timeline.py` on DMOG) show the device's work equal on + `argon_blueshift` and Julia's step idle 164 us against native's 88 (A40, binary64). + Tried and reverted, each with its numbers in the ledger: a whole-trial graph (an + order-dependent key), an order-independent one (phi functions to the largest width + cost more), fused device reductions (`ctc_reduced` 10 to 20 % slower in binary32). + What is left to try: a plane's observations in one Julia call (each call now waits + on the device separately, about 0.5 ms of idle a plane beyond native's), and graphs + on ROCm (AMDGPU.jl's stream capture, untried; the MI300X runs without them). 3. **The A40's remaining kernels:** the Adams predictor (0.1 to 0.28 ms a trial, its phi functions spilling, latency-bound on a mode-averaged state's few thousand elements) and radial's CUTLASS binary64 GEMMs (the A40 has no binary64 tensor diff --git a/julia/src/launch.jl b/julia/src/launch.jl index 0476dd54b..8431b6434 100644 --- a/julia/src/launch.jl +++ b/julia/src/launch.jl @@ -238,74 +238,22 @@ function reduce_each(f::F, op::O, neutral, c, nt::Integer, nm::Integer; heavy=fa return foldl(op, partials; init=neutral) end tally!(:readback) - out = scratch(c, :reduce_out, typeof(neutral), 1) - fused_reduce!(f, op, out, neutral, c, nt, nm) - @inbounds Array(out)[1] -end - -"""Fold `op` over `f(t, m)` at every sample into the device's `out[1]`, from `neutral`: -each element formed inside the reduction's first pass (one a thread up to 262144, then -strided), each block reduced in local memory, the blocks' partials reduced by one more -block. Nothing comes back to the host and nothing is allocated. Native's reductions are -shaped so; Julia's were an elementwise pass into scratch, then AK's reduction, which -finished its last stage on the host: about 50 us of an idle device a step on an A40 -(Nsight, `scripts/step_timeline.py`). The order is the tree's (SEP 25 bounds it).""" -function fused_reduce!(f::F, op::O, out, neutral, c, nt::Integer, nm::Integer) where {F,O} - CHECK[] && check_body(F) - n = Int(nt) * Int(nm) - blocks = clamp(cld(n, REDUCE_BLOCK), 1, REDUCE_PARTIALS) - partials = scratch(c, :reduce_partials, typeof(neutral), REDUCE_PARTIALS) - tally!(:launch, 2) - reduce_body!(c.backend, REDUCE_BLOCK)(partials, f, op, neutral, Int(nt), n; ndrange=blocks * REDUCE_BLOCK) - reduce_partials!(c.backend, REDUCE_BLOCK)(out, partials, op, neutral, blocks; ndrange=REDUCE_BLOCK) - out -end -const REDUCE_BLOCK = 256 -const REDUCE_PARTIALS = 1024 -KA.@kernel inbounds = true function reduce_body!(partials, f, op, neutral, nt, n) - local_index = KA.@index(Local, Linear) - group = KA.@index(Group, Linear) - groups = KA.@ndrange()[1] ÷ REDUCE_BLOCK - shared = KA.@localmem eltype(partials) (REDUCE_BLOCK,) - value = neutral - i = (group - 1) * REDUCE_BLOCK + local_index - while i <= n - m = (i - 1) ÷ nt + 1 - value = op(value, @inline f(i - (m - 1) * nt, m)) - i += groups * REDUCE_BLOCK - end - shared[local_index] = value - KA.@synchronize - width = REDUCE_BLOCK ÷ 2 - while width > 0 - if local_index <= width - shared[local_index] = op(shared[local_index], shared[local_index+width]) - end - KA.@synchronize - width ÷= 2 - end - local_index == 1 && (partials[group] = shared[1]) -end -KA.@kernel inbounds = true function reduce_partials!(out, @Const(partials), op, neutral, count) - local_index = KA.@index(Local, Linear) - shared = KA.@localmem eltype(out) (REDUCE_BLOCK,) - value = neutral - i = local_index - while i <= count - value = op(value, partials[i]) - i += REDUCE_BLOCK + # The bodies run as an elementwise kernel into scratch, inlined (`each_kernel!`), and + # only the values reduce: inside AK's reduction the body was a device call per + # element, and a heavy one got several elements a thread (six blocks for rdw's + # 10244, its predictor 539 us a trial on an A40). + scratch = SolpropJulia.scratch(c, heavy ? :heavy : :reduce, typeof(neutral), nt * nm) + each!(c, nt, nm) do t, m + @inbounds scratch[t+(m-1)*nt] = @inline f(t, m) end - shared[local_index] = value - KA.@synchronize - width = REDUCE_BLOCK ÷ 2 - while width > 0 - if local_index <= width - shared[local_index] = op(shared[local_index], shared[local_index+width]) - end - KA.@synchronize - width ÷= 2 + # The reduction's own scratch, kept (AK's `workspace`): a new partials buffer a call + # was an allocation from the pool and its copies, dozens a step. + workspace = get!(c.scratch, (:reduce_workspace, typeof(op), typeof(neutral), nt * nm)) do + AK.workspace(AK.mapreduce, identity, op, scratch; backend=c.backend, init=neutral, + neutral=neutral) end - local_index == 1 && (out[1] = shared[1]) + AK.mapreduce(identity, op, scratch; backend=c.backend, init=neutral, neutral=neutral, + workspace=workspace) end """The sum of `f(t, m)` over every sample into `out[1]`, which the next kernel reads: on a @@ -317,7 +265,13 @@ function sum_device!(f::F, out, c, nt::Integer, nm::Integer; heavy=false) where @inbounds out[1] = reduce_each(f, +, zero(eltype(out)), c, nt, nm; heavy=heavy) return out end - fused_reduce!(f, +, out, zero(eltype(out)), c, nt, nm) + terms = SolpropJulia.scratch(c, :sum_terms, eltype(out), 1, nt * nm) + each!(c, nt, nm) do t, m + @inbounds terms[1, t+(m-1)*nt] = @inline f(t, m) + end + tally!(:launch) + sum!(reshape(out, 1, 1), terms) + out end # FFTW's planner measures every plan unless SOLPROP_FFTW_PLAN says otherwise. Unlike From 6f686ea439080047c8cb5616588435d1e8b8071d Mon Sep 17 00:00:00 2001 From: John Travers Date: Mon, 9 Nov 2026 03:20:38 +0000 Subject: [PATCH 106/107] Julia experiment: a saved plane's host time on the A40, in the ledger and STATUS [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 10 ++++++++++ julia/STATUS.md | 8 +++++--- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 1b66a82e6..731922b6c 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3432,3 +3432,13 @@ graphs, shows no slower kernel on `ctc_reduced` (0.149 against 0.144 s), so the how the reductions sit beside the replayed graphs, not found. Neither version measures better over whole windows, so AK's reductions (with kept workspaces) stay; the per-trial host staging kept from `1b17fc75` is unchanged. + +**A saved plane on the A40** (`rdw`, binary64, one plane's window from the Nsight trace, +`scripts/plane_calls.py` on DMOG): a 3.7 ms window, of which the step itself is about +0.65 ms and the observation's device work a few microseconds a kernel. The rest is the +host: about 1.1 ms in stretches with no CUDA call at all (170, 360, 470 and 140 us) +between the adapter's Python-to-Julia calls (the state copy, the Poynting set, the +weight's rebinding, the populations, the boundary energies), and the calls' own small +copies and waits; CUDA.jl uploads each GEMM's two scalars separately (an allocation +from the pool and an 8-byte copy each). One Julia call a plane, returning everything the +plane's statistics need, is the change this points at. diff --git a/julia/STATUS.md b/julia/STATUS.md index bae655e30..6cc082c93 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -319,9 +319,11 @@ Roughly in order of what they would tell. Tried and reverted, each with its numbers in the ledger: a whole-trial graph (an order-dependent key), an order-independent one (phi functions to the largest width cost more), fused device reductions (`ctc_reduced` 10 to 20 % slower in binary32). - What is left to try: a plane's observations in one Julia call (each call now waits - on the device separately, about 0.5 ms of idle a plane beyond native's), and graphs - on ROCm (AMDGPU.jl's stream capture, untried; the MI300X runs without them). + What is left to try: a plane's observations in one Julia call (a plane's window on + `rdw` holds about 1.1 ms of host time with no CUDA call, between the adapter's + separate Python-to-Julia calls; the ledger has the sequence), the GEMMs' scalars + uploaded once rather than per call, and graphs on ROCm (AMDGPU.jl's stream capture, + untried; the MI300X runs without them). 3. **The A40's remaining kernels:** the Adams predictor (0.1 to 0.28 ms a trial, its phi functions spilling, latency-bound on a mode-averaged state's few thousand elements) and radial's CUTLASS binary64 GEMMs (the A40 has no binary64 tensor From b84d3ab81df863669e57aeca6c0ac3abaf6820ac Mon Sep 17 00:00:00 2001 From: John Travers Date: Mon, 9 Nov 2026 05:28:50 +0000 Subject: [PATCH 107/107] Julia experiment: the H100 at 6f686ea4 (1.25 against native, binary64) [skip ci] Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01HAYtF8VxmP17Bx5wGFqR2R --- docs/dev/benchmarks.md | 6 ++++++ julia/STATUS.md | 5 +++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/docs/dev/benchmarks.md b/docs/dev/benchmarks.md index 731922b6c..4949fde21 100644 --- a/docs/dev/benchmarks.md +++ b/docs/dev/benchmarks.md @@ -3442,3 +3442,9 @@ weight's rebinding, the populations, the boundary energies), and the calls' own copies and waits; CUDA.jl uploads each GEMM's two scalars separately (an allocation from the pool and an 8-byte copy each). One Julia call a plane, returning everything the plane's statistics need, is the change this points at. + +**NVIDIA H100** (DigitalOcean, tor1, CUDA 13.1, 20 host cores) at `6f686ea4` (source +graphs, direct copies; native's build HOPPER90), binary64, 3 rounds: native against +Julia 1.25 (`kerr_beam_192` 0.66, `ctc_reduced` 0.98, `h2_raman_6ps` 1.13, +`argon_blueshift` 1.42, `rdw` 1.59, radial 1.60, `line` 1.77; fields within 4e-14). The +H200 at `67491bf9`, before the graphs and the copy fix, was 1.69. diff --git a/julia/STATUS.md b/julia/STATUS.md index 6cc082c93..efc533613 100644 --- a/julia/STATUS.md +++ b/julia/STATUS.md @@ -279,8 +279,9 @@ on Metal, so it is CUDA's only. On the A40, in binary64, native against Julia went from 1.80 in the morning to 1.15 at `51a153de` (binary32 df32 from 1.56 to 0.79: Julia faster in five of seven cases), and -the H200 at `67491bf9` is 1.69 (2.39 before), and an AMD MI300X at `1b17fc75` 1.28 (the -MI325X's was 2.48), without graphs, which are CUDA's only so far. In order of what each change bought on the A40 (the ledger has every row): +the H200 at `67491bf9` was 1.69 (2.39 before), an H100 at `6f686ea4` (with the graphs and +the copy fix) is 1.25, and an AMD MI300X at `1b17fc75` 1.28 (the MI325X's was 2.48), +without graphs, which are CUDA's only so far. In order of what each change bought on the A40 (the ledger has every row): - **Kernel bodies inlined** (`@inline f(t, m)` in the GPU kernel): left to the inliner, a body was a device call per sample with its arguments in local memory, 9 times slower in binary64 and 20 in binary32. 0.70 / 0.62 over the seven cases.