diff --git a/Manifest-v1.10.toml b/Manifest-v1.10.toml new file mode 100644 index 00000000..d67194f6 --- /dev/null +++ b/Manifest-v1.10.toml @@ -0,0 +1,1300 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.10.9" +manifest_format = "2.0" +project_hash = "12799e84b2a5b02aa393e741413498f4973e33be" + +[[deps.ADTypes]] +git-tree-sha1 = "e2478490447631aedba0823d4d7a80b2cc8cdb32" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "1.14.0" +weakdeps = ["ChainRulesCore", "ConstructionBase", "EnzymeCore"] + + [deps.ADTypes.extensions] + ADTypesChainRulesCoreExt = "ChainRulesCore" + ADTypesConstructionBaseExt = "ConstructionBase" + ADTypesEnzymeCoreExt = "EnzymeCore" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"] +git-tree-sha1 = "3b86719127f50670efe356bc11073d84b4ed7a5d" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.42" + + [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", "Requires"] +git-tree-sha1 = "f7817e2e585aa6d924fd714df1e2a84be7896c60" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.3.0" +weakdeps = ["SparseArrays", "StaticArrays"] + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.1" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "017fcb757f8e921fb44ee063a7aafe5f89b86dd1" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.18.0" + + [deps.ArrayInterface.extensions] + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = "CUDSS" + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + 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" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + 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.ArrayLayouts]] +deps = ["FillArrays", "LinearAlgebra"] +git-tree-sha1 = "4e25216b8fea1908a0ce0f5d87368587899f75be" +uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a" +version = "1.11.1" +weakdeps = ["SparseArrays"] + + [deps.ArrayLayouts.extensions] + ArrayLayoutsSparseArraysExt = "SparseArrays" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" + +[[deps.AxisAlgorithms]] +deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"] +git-tree-sha1 = "01b8ccb13d68535d73d2b0c23e39bd23155fb712" +uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950" +version = "1.1.0" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.BracketingNonlinearSolve]] +deps = ["CommonSolve", "ConcreteStructs", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "95cb19c37ea427617e9795655667712f03058d98" +uuid = "70df07ce-3d50-431d-a3e7-ca6ddb60ac1e" +version = "1.1.0" +weakdeps = ["ForwardDiff"] + + [deps.BracketingNonlinearSolve.extensions] + BracketingNonlinearSolveForwardDiffExt = "ForwardDiff" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Static"] +git-tree-sha1 = "5a97e67919535d6841172016c9530fd69494e5ec" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.6" + +[[deps.ChainRulesCore]] +deps = ["Compat", "LinearAlgebra"] +git-tree-sha1 = "1713c74e00545bfe14605d2a2be1712de8fbcb58" +uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +version = "1.25.1" +weakdeps = ["SparseArrays"] + + [deps.ChainRulesCore.extensions] + ChainRulesCoreSparseArraysExt = "SparseArrays" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.ColorTypes]] +deps = ["FixedPointNumbers", "Random"] +git-tree-sha1 = "c7acce7a7e1078a20a285211dd73cd3941a871d6" +uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" +version = "0.12.0" + + [deps.ColorTypes.extensions] + StyledStringsExt = "StyledStrings" + + [deps.ColorTypes.weakdeps] + StyledStrings = "f489334b-da3d-4c2e-b8f0-e476e12c162b" + +[[deps.Colors]] +deps = ["ColorTypes", "FixedPointNumbers", "Reexport"] +git-tree-sha1 = "64e15186f0aa277e174aa81798f7eb8598e0157e" +uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" +version = "0.13.0" + +[[deps.CommonSolve]] +git-tree-sha1 = "0eee5eb66b1cf62cd6ad1b460238e60e4b09400c" +uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" +version = "0.2.4" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools"] +git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.1" + +[[deps.CommonWorldInvalidations]] +git-tree-sha1 = "ae52d1c52048455e85a387fbee9be553ec2b68d0" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.0.0" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "8ae8d32e09f0dcf42a36b90d4e17f5dd2e4c4215" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.16.0" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.1.1+0" + +[[deps.CompositionsBase]] +git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" +uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b" +version = "0.1.2" +weakdeps = ["InverseFunctions"] + + [deps.CompositionsBase.extensions] + CompositionsBaseInverseFunctionsExt = "InverseFunctions" + +[[deps.ConcreteStructs]] +git-tree-sha1 = "f749037478283d372048690eb3b5f92a79432b34" +uuid = "2569d6c7-a4a2-43d3-a901-331e8e4be471" +version = "0.2.3" + +[[deps.ConstructionBase]] +git-tree-sha1 = "76219f1ed5771adbb096743bff43fb5fdd4c1157" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.5.8" + + [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"] +git-tree-sha1 = "fcbb72b032692610bfbdb15018ac16a36cf2e406" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.1" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataStructures]] +deps = ["Compat", "InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "1d0a14036acb104d9e89698bd408f63ab58cdc82" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.18.20" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[deps.DefaultApplication]] +deps = ["InteractiveUtils"] +git-tree-sha1 = "c0dfa5a35710a193d83f03124356eef3386688fc" +uuid = "3f0dd361-4fe0-5fc6-8523-80b14ec94d85" +version = "1.1.0" + +[[deps.DelimitedFiles]] +deps = ["Mmap"] +git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae" +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" +version = "1.9.1" + +[[deps.DiffEqBase]] +deps = ["ArrayInterface", "ConcreteStructs", "DataStructures", "DocStringExtensions", "EnumX", "EnzymeCore", "FastBroadcast", "FastClosures", "FastPower", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "Logging", "Markdown", "MuladdMacro", "Parameters", "PrecompileTools", "Printf", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators", "SciMLStructures", "Setfield", "Static", "StaticArraysCore", "Statistics", "TruncatedStacktraces"] +git-tree-sha1 = "615e8358608628b9768275f4bd8c237724e72f08" +uuid = "2b5f629d-d688-5b77-993f-72d75c75574e" +version = "6.164.2" + + [deps.DiffEqBase.extensions] + DiffEqBaseCUDAExt = "CUDA" + DiffEqBaseChainRulesCoreExt = "ChainRulesCore" + DiffEqBaseDistributionsExt = "Distributions" + DiffEqBaseEnzymeExt = ["ChainRulesCore", "Enzyme"] + DiffEqBaseForwardDiffExt = ["ForwardDiff"] + DiffEqBaseGTPSAExt = "GTPSA" + DiffEqBaseGeneralizedGeneratedExt = "GeneralizedGenerated" + DiffEqBaseMPIExt = "MPI" + DiffEqBaseMeasurementsExt = "Measurements" + DiffEqBaseMonteCarloMeasurementsExt = "MonteCarloMeasurements" + DiffEqBaseReverseDiffExt = "ReverseDiff" + DiffEqBaseSparseArraysExt = "SparseArrays" + DiffEqBaseTrackerExt = "Tracker" + DiffEqBaseUnitfulExt = "Unitful" + + [deps.DiffEqBase.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + GeneralizedGenerated = "6b9d7cbe-bcb9-11e9-073f-15a7a543e2eb" + MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.DiffResults]] +deps = ["StaticArraysCore"] +git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.1.0" + +[[deps.DiffRules]] +deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.15.1" + +[[deps.DifferentiationInterface]] +deps = ["ADTypes", "LinearAlgebra"] +git-tree-sha1 = "3999a7934cc723719e79ff7db33160b141297444" +uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +version = "0.6.44" + + [deps.DifferentiationInterface.extensions] + DifferentiationInterfaceChainRulesCoreExt = "ChainRulesCore" + DifferentiationInterfaceDiffractorExt = "Diffractor" + DifferentiationInterfaceEnzymeExt = ["EnzymeCore", "Enzyme"] + DifferentiationInterfaceFastDifferentiationExt = "FastDifferentiation" + DifferentiationInterfaceFiniteDiffExt = "FiniteDiff" + DifferentiationInterfaceFiniteDifferencesExt = "FiniteDifferences" + DifferentiationInterfaceForwardDiffExt = ["ForwardDiff", "DiffResults"] + DifferentiationInterfaceGTPSAExt = "GTPSA" + DifferentiationInterfaceMooncakeExt = "Mooncake" + DifferentiationInterfacePolyesterForwardDiffExt = ["PolyesterForwardDiff", "ForwardDiff", "DiffResults"] + DifferentiationInterfaceReverseDiffExt = ["ReverseDiff", "DiffResults"] + DifferentiationInterfaceSparseArraysExt = "SparseArrays" + DifferentiationInterfaceSparseConnectivityTracerExt = "SparseConnectivityTracer" + DifferentiationInterfaceSparseMatrixColoringsExt = "SparseMatrixColorings" + DifferentiationInterfaceStaticArraysExt = "StaticArrays" + DifferentiationInterfaceSymbolicsExt = "Symbolics" + DifferentiationInterfaceTrackerExt = "Tracker" + DifferentiationInterfaceZygoteExt = ["Zygote", "ForwardDiff"] + + [deps.DifferentiationInterface.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" + Diffractor = "9f5e2b26-1114-432f-b630-d3fe2085c51c" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastDifferentiation = "eb9bf01b-bf85-4b60-bf87-ee5de06c00be" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PolyesterForwardDiff = "98d1487c-24ca-40b6-b7ab-df2af84e126b" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[deps.DocStringExtensions]] +deps = ["LibGit2"] +git-tree-sha1 = "2fb1e02f2b635d0845df5d7c167fec4dd739b00d" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.3" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[deps.EnumX]] +git-tree-sha1 = "bdb1942cd4c45e3c678fd11569d5cccd80976237" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.4" + +[[deps.EnzymeCore]] +git-tree-sha1 = "0cdb7af5c39e92d78a0ee8d0a447d32f7593137e" +uuid = "f151be2c-9106-41f4-ab19-57ee4f262869" +version = "0.8.8" +weakdeps = ["Adapt"] + + [deps.EnzymeCore.extensions] + AdaptExt = "Adapt" + +[[deps.ExprTools]] +git-tree-sha1 = "27415f162e6028e81c72b82ef756bf321213b6ec" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.10" + +[[deps.ExproniconLite]] +git-tree-sha1 = "c13f0b150373771b0fdc1713c97860f8df12e6c2" +uuid = "55351af7-c7e9-48d6-89ff-24e801d99491" +version = "0.10.14" + +[[deps.FastBroadcast]] +deps = ["ArrayInterface", "LinearAlgebra", "Polyester", "Static", "StaticArrayInterface", "StrideArraysCore"] +git-tree-sha1 = "ab1b34570bcdf272899062e1a56285a53ecaae08" +uuid = "7034ab61-46d4-4ed7-9d0f-46aef9175898" +version = "0.3.5" + +[[deps.FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" + +[[deps.FastPower]] +git-tree-sha1 = "58c3431137131577a7c379d00fea00be524338fb" +uuid = "a4df4552-cc26-4903-aec0-212e50a0e84b" +version = "1.1.1" + + [deps.FastPower.extensions] + FastPowerEnzymeExt = "Enzyme" + FastPowerForwardDiffExt = "ForwardDiff" + FastPowerMeasurementsExt = "Measurements" + FastPowerMonteCarloMeasurementsExt = "MonteCarloMeasurements" + FastPowerReverseDiffExt = "ReverseDiff" + FastPowerTrackerExt = "Tracker" + + [deps.FastPower.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" + +[[deps.FillArrays]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "6a70198746448456524cb442b8af316927ff3e1a" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.13.0" + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStatisticsExt = "Statistics" + + [deps.FillArrays.weakdeps] + PDMats = "90014a1f-27ba-587c-ab20-58faa44d9150" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[deps.FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Setfield"] +git-tree-sha1 = "f089ab1f834470c525562030c8cfde4025d5e915" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.27.0" + + [deps.FiniteDiff.extensions] + FiniteDiffBandedMatricesExt = "BandedMatrices" + FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffSparseArraysExt = "SparseArrays" + FiniteDiffStaticArraysExt = "StaticArrays" + + [deps.FiniteDiff.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.FixedPointNumbers]] +deps = ["Statistics"] +git-tree-sha1 = "05882d6995ae5c12bb5f36dd2ed3f61c98cbb172" +uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +version = "0.8.5" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "a2df1b776752e3f344e5116c06d75a10436ab853" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "0.10.38" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.3" + +[[deps.FunctionWrappersWrappers]] +deps = ["FunctionWrappers"] +git-tree-sha1 = "b104d487b34566608f8b4e1c39fb0b10aa279ff8" +uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf" +version = "0.1.3" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "83cf05ab16a73219e5f6bd1bdfa9848fa24ac627" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "0f14a5456bdc6b9731a5682f439a672750a09e48" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.0.4+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[deps.Interpolations]] +deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] +git-tree-sha1 = "88a101217d7cb38a7b481ccd50d21876e1d1b0e0" +uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" +version = "0.15.1" + + [deps.Interpolations.extensions] + InterpolationsUnitfulExt = "Unitful" + + [deps.Interpolations.weakdeps] + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.InverseFunctions]] +git-tree-sha1 = "a779299d77cd080bf77b97535acecd73e1c5e5cb" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.17" + + [deps.InverseFunctions.extensions] + InverseFunctionsDatesExt = "Dates" + InverseFunctionsTestExt = "Test" + + [deps.InverseFunctions.weakdeps] + Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "e2222959fbc6c19554dc15174c81bf7bf3aa691c" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.4" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "a007feb38b422fbdab534406aeca1b86823cb4d6" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.7.0" + +[[deps.Jieko]] +deps = ["ExproniconLite"] +git-tree-sha1 = "2f05ed29618da60c06a87e9c033982d4f71d0b6c" +uuid = "ae98c720-c025-4a4a-838c-29b094483192" +version = "0.2.1" + +[[deps.Krylov]] +deps = ["LinearAlgebra", "Printf", "SparseArrays"] +git-tree-sha1 = "b29d37ce30fa401a4563b18880ab91f979a29734" +uuid = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7" +version = "0.9.10" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.0" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazyArrays]] +deps = ["ArrayLayouts", "FillArrays", "LinearAlgebra", "MacroTools", "SparseArrays"] +git-tree-sha1 = "866ce84b15e54d758c11946aacd4e5df0e60b7a3" +uuid = "5078a376-72f3-5289-bfd5-ec5146d43c02" +version = "2.6.1" + + [deps.LazyArrays.extensions] + LazyArraysBandedMatricesExt = "BandedMatrices" + LazyArraysBlockArraysExt = "BlockArrays" + LazyArraysBlockBandedMatricesExt = "BlockBandedMatrices" + LazyArraysStaticArraysExt = "StaticArrays" + + [deps.LazyArrays.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "0.6.4" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.4.0+0" + +[[deps.LibGit2]] +deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.6.4+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.0+1" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[deps.LineSearch]] +deps = ["ADTypes", "CommonSolve", "ConcreteStructs", "FastClosures", "LinearAlgebra", "MaybeInplace", "SciMLBase", "SciMLJacobianOperators", "StaticArraysCore"] +git-tree-sha1 = "97d502765cc5cf3a722120f50da03c2474efce04" +uuid = "87fe0de2-c867-4266-b59a-2f0a94fc965b" +version = "0.1.4" + + [deps.LineSearch.extensions] + LineSearchLineSearchesExt = "LineSearches" + + [deps.LineSearch.weakdeps] + LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[deps.LinearSolve]] +deps = ["ArrayInterface", "ChainRulesCore", "ConcreteStructs", "DocStringExtensions", "EnumX", "GPUArraysCore", "InteractiveUtils", "Krylov", "LazyArrays", "Libdl", "LinearAlgebra", "MKL_jll", "Markdown", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators", "Setfield", "StaticArraysCore", "UnPack"] +git-tree-sha1 = "6e975dea0fc1825ef3bc83c11281fdf745a69a43" +uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" +version = "3.4.0" + + [deps.LinearSolve.extensions] + LinearSolveBandedMatricesExt = "BandedMatrices" + LinearSolveBlockDiagonalsExt = "BlockDiagonals" + LinearSolveCUDAExt = "CUDA" + LinearSolveCUDSSExt = "CUDSS" + LinearSolveEnzymeExt = "EnzymeCore" + LinearSolveFastAlmostBandedMatricesExt = "FastAlmostBandedMatrices" + LinearSolveFastLapackInterfaceExt = "FastLapackInterface" + LinearSolveHYPREExt = "HYPRE" + LinearSolveIterativeSolversExt = "IterativeSolvers" + LinearSolveKernelAbstractionsExt = "KernelAbstractions" + LinearSolveKrylovKitExt = "KrylovKit" + LinearSolveMetalExt = "Metal" + LinearSolvePardisoExt = ["Pardiso", "SparseArrays"] + LinearSolveRecursiveFactorizationExt = "RecursiveFactorization" + LinearSolveSparseArraysExt = "SparseArrays" + LinearSolveSparspakExt = ["SparseArrays", "Sparspak"] + + [deps.LinearSolve.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockDiagonals = "0a1fb500-61f7-11e9-3c65-f5ef3456f9f0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastAlmostBandedMatrices = "9d29842c-ecb8-4973-b1e9-a27b1157504e" + FastLapackInterface = "29a986be-02c6-4525-aec4-84b980013641" + HYPRE = "b5ffcf37-a2bd-41ab-a3da-4bd9bc8ad771" + IterativeSolvers = "42fd0dbc-a981-5370-80f2-aaf504508153" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2" + RecursiveFactorization = "f2c3362d-daeb-58d1-803e-2bc74f2840b4" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Sparspak = "e56a9233-b9d6-4f03-8d0f-1825330902ac" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.3.29" + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + + [deps.LogExpFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ChangesOfVariables = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "5de60bc6cb3899cd318d80d627560fae2e2d99ae" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.0.1+1" + +[[deps.MacroTools]] +git-tree-sha1 = "72aebe0b5051e5143a079a4685a46da330a40472" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.15" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[deps.MaybeInplace]] +deps = ["ArrayInterface", "LinearAlgebra", "MacroTools"] +git-tree-sha1 = "54e2fdc38130c05b42be423e90da3bade29b74bd" +uuid = "bb5d69b7-63fc-4a16-80bd-7e42200c7bdb" +version = "0.1.4" +weakdeps = ["SparseArrays"] + + [deps.MaybeInplace.extensions] + MaybeInplaceSparseArraysExt = "SparseArrays" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.2+1" + +[[deps.Measures]] +git-tree-sha1 = "c13304c81eec1ed3af7fc20e75fb6b26092a1102" +uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e" +version = "0.3.2" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" + +[[deps.Moshi]] +deps = ["ExproniconLite", "Jieko"] +git-tree-sha1 = "453de0fc2be3d11b9b93ca4d0fddd91196dcf1ed" +uuid = "2e0e35c7-a2e4-4343-998d-7ef72827ed2d" +version = "0.3.5" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2023.1.10" + +[[deps.MuladdMacro]] +git-tree-sha1 = "cac9cc5499c25554cba55cd3c30543cff5ca4fab" +uuid = "46d2c3a1-f734-5fdb-9937-b9b9aeba4221" +version = "0.2.4" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "cc0a5deefdb12ab3a096f00a6d42133af4560d71" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.1.2" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.2.0" + +[[deps.NonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "BracketingNonlinearSolve", "CommonSolve", "ConcreteStructs", "DiffEqBase", "DifferentiationInterface", "FastClosures", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "LinearSolve", "NonlinearSolveBase", "NonlinearSolveFirstOrder", "NonlinearSolveQuasiNewton", "NonlinearSolveSpectralMethods", "PrecompileTools", "Preferences", "Reexport", "SciMLBase", "SimpleNonlinearSolve", "SparseArrays", "SparseMatrixColorings", "StaticArraysCore", "SymbolicIndexingInterface"] +git-tree-sha1 = "95def4e218a6832d158feafb9963be0337ea432c" +uuid = "8913a72c-1f9b-4ce2-8d82-65094dcecaec" +version = "4.4.0" + + [deps.NonlinearSolve.extensions] + NonlinearSolveFastLevenbergMarquardtExt = "FastLevenbergMarquardt" + NonlinearSolveFixedPointAccelerationExt = "FixedPointAcceleration" + NonlinearSolveLeastSquaresOptimExt = "LeastSquaresOptim" + NonlinearSolveMINPACKExt = "MINPACK" + NonlinearSolveNLSolversExt = "NLSolvers" + NonlinearSolveNLsolveExt = ["NLsolve", "LineSearches"] + NonlinearSolvePETScExt = ["PETSc", "MPI"] + NonlinearSolveSIAMFANLEquationsExt = "SIAMFANLEquations" + NonlinearSolveSpeedMappingExt = "SpeedMapping" + NonlinearSolveSundialsExt = "Sundials" + + [deps.NonlinearSolve.weakdeps] + FastLevenbergMarquardt = "7a0df574-e128-4d35-8cbd-3d84502bf7ce" + FixedPointAcceleration = "817d07cb-a79a-5c30-9a31-890123675176" + LeastSquaresOptim = "0fc2ff8b-aaa3-5acd-a817-1944a5e08891" + LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" + MINPACK = "4854310b-de5a-5eb6-a2a5-c1dee2bd17f9" + MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" + NLSolvers = "337daf1e-9722-11e9-073e-8b9effe078ba" + NLsolve = "2774e3e8-f4cf-5e23-947b-6d7e65073b56" + PETSc = "ace2c81b-2b5f-4b1e-a30d-d662738edfe0" + SIAMFANLEquations = "084e46ad-d928-497d-ad5e-07fa361a48c4" + SpeedMapping = "f1835b91-879b-4a3f-a438-e4baacf14412" + Sundials = "c3572dad-4567-51f8-b174-8c6c989267f4" + +[[deps.NonlinearSolveBase]] +deps = ["ADTypes", "Adapt", "ArrayInterface", "CommonSolve", "Compat", "ConcreteStructs", "DifferentiationInterface", "EnzymeCore", "FastClosures", "LinearAlgebra", "Markdown", "MaybeInplace", "Preferences", "Printf", "RecursiveArrayTools", "SciMLBase", "SciMLJacobianOperators", "SciMLOperators", "StaticArraysCore", "SymbolicIndexingInterface", "TimerOutputs"] +git-tree-sha1 = "8a2437b5ead050301b6a6258f226e5137e511000" +uuid = "be0214bd-f91f-a760-ac4e-3421ce2b2da0" +version = "1.5.0" + + [deps.NonlinearSolveBase.extensions] + NonlinearSolveBaseBandedMatricesExt = "BandedMatrices" + NonlinearSolveBaseDiffEqBaseExt = "DiffEqBase" + NonlinearSolveBaseForwardDiffExt = "ForwardDiff" + NonlinearSolveBaseLineSearchExt = "LineSearch" + NonlinearSolveBaseLinearSolveExt = "LinearSolve" + NonlinearSolveBaseSparseArraysExt = "SparseArrays" + NonlinearSolveBaseSparseMatrixColoringsExt = "SparseMatrixColorings" + + [deps.NonlinearSolveBase.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + LineSearch = "87fe0de2-c867-4266-b59a-2f0a94fc965b" + LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + +[[deps.NonlinearSolveFirstOrder]] +deps = ["ADTypes", "ArrayInterface", "CommonSolve", "ConcreteStructs", "DiffEqBase", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "LinearSolve", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLJacobianOperators", "Setfield", "StaticArraysCore"] +git-tree-sha1 = "aade7ab02ee4c80ec30dc8a2874fc67155c935f1" +uuid = "5959db7a-ea39-4486-b5fe-2dd0bf03d60d" +version = "1.3.0" + +[[deps.NonlinearSolveQuasiNewton]] +deps = ["ArrayInterface", "CommonSolve", "ConcreteStructs", "DiffEqBase", "LinearAlgebra", "LinearSolve", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLOperators", "StaticArraysCore"] +git-tree-sha1 = "44a132cb32aeafcb35a6238fd91a2f3f8ff5c5b0" +uuid = "9a2c21bd-3a47-402d-9113-8faf9a0ee114" +version = "1.2.0" +weakdeps = ["ForwardDiff"] + + [deps.NonlinearSolveQuasiNewton.extensions] + NonlinearSolveQuasiNewtonForwardDiffExt = "ForwardDiff" + +[[deps.NonlinearSolveSpectralMethods]] +deps = ["CommonSolve", "ConcreteStructs", "DiffEqBase", "LineSearch", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "f28b1ab17b5f15eb2b174eaf8813cf17f0b3e6c0" +uuid = "26075421-4e9a-44e1-8bd1-420ed7ad02b2" +version = "1.1.0" +weakdeps = ["ForwardDiff"] + + [deps.NonlinearSolveSpectralMethods.extensions] + NonlinearSolveSpectralMethodsForwardDiffExt = "ForwardDiff" + +[[deps.OffsetArrays]] +git-tree-sha1 = "5e1897147d1ff8d98883cda2be2187dcf57d8f0c" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.15.0" +weakdeps = ["Adapt"] + + [deps.OffsetArrays.extensions] + OffsetArraysAdaptExt = "Adapt" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.23+4" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.1+4" + +[[deps.OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1346c9208249809840c91b26703912dff463d335" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.6+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "cc4054e898b852042d7b503313f7ad03de99c3dd" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.0" + +[[deps.Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.3" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.10.0" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "6d38fea02d983051776a856b7df75b30cf9a3c1f" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.16" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PreallocationTools]] +deps = ["Adapt", "ArrayInterface", "ForwardDiff"] +git-tree-sha1 = "8765738bc5a6f1554cb61c5ddfae5bf279e8b110" +uuid = "d236fae5-4411-538c-8e31-a6e3d9e00b46" +version = "0.4.25" + + [deps.PreallocationTools.extensions] + PreallocationToolsReverseDiffExt = "ReverseDiff" + PreallocationToolsSparseConnectivityTracerExt = "SparseConnectivityTracer" + + [deps.PreallocationTools.weakdeps] + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.2.1" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "9306f6085165d270f7e3db02af26a400d580f5c6" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.4.3" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[deps.REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[deps.Ratios]] +deps = ["Requires"] +git-tree-sha1 = "1342a47bf3260ee108163042310d26f2be5ec90b" +uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439" +version = "0.4.5" +weakdeps = ["FixedPointNumbers"] + + [deps.Ratios.extensions] + RatiosFixedPointNumbersExt = "FixedPointNumbers" + +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.RecursiveArrayTools]] +deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "IteratorInterfaceExtensions", "LinearAlgebra", "RecipesBase", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables"] +git-tree-sha1 = "35ac79a85c8086892258581d8b6df9cd8db5c91a" +uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" +version = "3.31.1" + + [deps.RecursiveArrayTools.extensions] + RecursiveArrayToolsFastBroadcastExt = "FastBroadcast" + RecursiveArrayToolsForwardDiffExt = "ForwardDiff" + RecursiveArrayToolsMeasurementsExt = "Measurements" + RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements" + RecursiveArrayToolsReverseDiffExt = ["ReverseDiff", "Zygote"] + RecursiveArrayToolsSparseArraysExt = ["SparseArrays"] + RecursiveArrayToolsStructArraysExt = "StructArrays" + RecursiveArrayToolsTrackerExt = "Tracker" + RecursiveArrayToolsZygoteExt = "Zygote" + + [deps.RecursiveArrayTools.weakdeps] + FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.1" + +[[deps.RuntimeGeneratedFunctions]] +deps = ["ExprTools", "SHA", "Serialization"] +git-tree-sha1 = "04c968137612c4a5629fa531334bb81ad5680f00" +uuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" +version = "0.5.13" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SciMLBase]] +deps = ["ADTypes", "Accessors", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "Moshi", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "SciMLStructures", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface"] +git-tree-sha1 = "ee305515b0946db5f56af699e8b5804fee04146c" +uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" +version = "2.75.1" + + [deps.SciMLBase.extensions] + SciMLBaseChainRulesCoreExt = "ChainRulesCore" + SciMLBaseMLStyleExt = "MLStyle" + SciMLBaseMakieExt = "Makie" + SciMLBasePartialFunctionsExt = "PartialFunctions" + SciMLBasePyCallExt = "PyCall" + SciMLBasePythonCallExt = "PythonCall" + SciMLBaseRCallExt = "RCall" + SciMLBaseZygoteExt = "Zygote" + + [deps.SciMLBase.weakdeps] + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + RCall = "6f49c342-dc21-5d91-9882-a32aef131414" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.SciMLJacobianOperators]] +deps = ["ADTypes", "ArrayInterface", "ConcreteStructs", "ConstructionBase", "DifferentiationInterface", "FastClosures", "LinearAlgebra", "SciMLBase", "SciMLOperators"] +git-tree-sha1 = "f66048bb969e67bd7d1bdd03cd0b81219642bbd0" +uuid = "19f34311-ddf3-4b8b-af20-060888a46c0e" +version = "0.1.1" + +[[deps.SciMLOperators]] +deps = ["Accessors", "ArrayInterface", "DocStringExtensions", "LinearAlgebra", "MacroTools"] +git-tree-sha1 = "6149620767866d4b0f0f7028639b6e661b6a1e44" +uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" +version = "0.3.12" +weakdeps = ["SparseArrays", "StaticArraysCore"] + + [deps.SciMLOperators.extensions] + SciMLOperatorsSparseArraysExt = "SparseArrays" + SciMLOperatorsStaticArraysCoreExt = "StaticArraysCore" + +[[deps.SciMLStructures]] +deps = ["ArrayInterface"] +git-tree-sha1 = "566c4ed301ccb2a44cbd5a27da5f885e0ed1d5df" +uuid = "53ae85a6-f571-4167-b2af-e1d143709226" +version = "1.7.0" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"] +git-tree-sha1 = "c5391c6ace3bc430ca630251d02ea9687169ca68" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "1.1.2" + +[[deps.SharedArrays]] +deps = ["Distributed", "Mmap", "Random", "Serialization"] +uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" + +[[deps.SimpleNonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "BracketingNonlinearSolve", "CommonSolve", "ConcreteStructs", "DifferentiationInterface", "FastClosures", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "Setfield", "StaticArraysCore"] +git-tree-sha1 = "a3868a6add9f5989d1f4bd21de0333ef89fb9d9f" +uuid = "727e6d20-b764-4bd8-a329-72de5adea6c7" +version = "2.1.0" + + [deps.SimpleNonlinearSolve.extensions] + SimpleNonlinearSolveChainRulesCoreExt = "ChainRulesCore" + SimpleNonlinearSolveDiffEqBaseExt = "DiffEqBase" + SimpleNonlinearSolveReverseDiffExt = "ReverseDiff" + SimpleNonlinearSolveTrackerExt = "Tracker" + + [deps.SimpleNonlinearSolve.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.10.0" + +[[deps.SparseMatrixColorings]] +deps = ["ADTypes", "DataStructures", "DocStringExtensions", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "e0ae9189392572abe85bc9fd4ce35e772b1e1e10" +uuid = "0a514795-09f3-496d-8182-132a7b665d35" +version = "0.4.14" +weakdeps = ["Colors"] + + [deps.SparseMatrixColorings.extensions] + SparseMatrixColoringsColorsExt = "Colors" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "64cca0c26b4f31ba18f13f6c12af7c85f478cfde" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.5.0" +weakdeps = ["ChainRulesCore"] + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools"] +git-tree-sha1 = "f737d444cb0ad07e61b3c1bef8eb91203c321eff" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.2.0" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "Static"] +git-tree-sha1 = "96381d50f1ce85f2663584c8e886a6ca97e60554" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.8.0" +weakdeps = ["OffsetArrays", "StaticArrays"] + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "0feb6b9031bd5c51f9072393eb5ab3efd31bf9e4" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.9.13" +weakdeps = ["ChainRulesCore", "Statistics"] + + [deps.StaticArrays.extensions] + StaticArraysChainRulesCoreExt = "ChainRulesCore" + StaticArraysStatisticsExt = "Statistics" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "192954ef1208c7019899fbf8049e717f92959682" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.3" + +[[deps.Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.10.0" + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "f35f6ab602df8413a50c4a25ca14de821e8605fb" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.7" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.2.1+1" + +[[deps.SymbolicIndexingInterface]] +deps = ["Accessors", "ArrayInterface", "RuntimeGeneratedFunctions", "StaticArraysCore"] +git-tree-sha1 = "d6c04e26aa1c8f7d144e1a8c47f1c73d3013e289" +uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5" +version = "0.3.38" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "598cd7c1f68d1e205689b1c2fe65a9f85846f297" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.12.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.TestEnv]] +deps = ["Pkg"] +git-tree-sha1 = "2a57e05cb9854e7260c354f1bcdbe5190adba19f" +uuid = "1e6cf692-eddd-4d53-88a5-2d735e33781b" +version = "1.102.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "eda08f7e9818eb53661b3deb74e3159460dfbc27" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.2" + +[[deps.TimerOutputs]] +deps = ["ExprTools", "Printf"] +git-tree-sha1 = "f57facfd1be61c42321765d3551b3df50f7e09f6" +uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" +version = "0.5.28" + + [deps.TimerOutputs.extensions] + FlameGraphsExt = "FlameGraphs" + + [deps.TimerOutputs.weakdeps] + FlameGraphs = "08572546-2f56-4bcf-ba4e-bab62c3a3f89" + +[[deps.Timers]] +deps = ["Pkg", "TestEnv"] +git-tree-sha1 = "fe7046d2b5bc1d31cde8fd19fad7c5506e3960b4" +uuid = "21f18d07-b854-4dab-86f0-c15a3821819a" +version = "0.1.5" + +[[deps.TruncatedStacktraces]] +deps = ["InteractiveUtils", "MacroTools", "Preferences"] +git-tree-sha1 = "ea3e54c2bdde39062abf5a9758a23735558705e1" +uuid = "781d530d-4396-4725-bb49-402e4bee1e77" +version = "1.4.0" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[deps.WoodburyMatrices]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "c1a7aa6219628fcd757dede0ca95e245c5cd9511" +uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6" +version = "1.0.0" + +[[deps.Xfoil]] +deps = ["Printf", "xfoil_light_jll"] +git-tree-sha1 = "752ff27037088b747d3138c828ffc0968d2e7766" +uuid = "19641d66-a62d-11e8-2441-8f57a969a9c4" +version = "0.5.0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.13+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.11.0+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.52.0+1" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d5a767a3bb77135a99e433afe0eb14cd7f6914c3" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2022.0.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.4.0+2" + +[[deps.xfoil_light_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "1ebea4f4577b2aa95d4151e11ed6210341e76f62" +uuid = "70cc596b-f351-5640-b155-76ddf0ff62ca" +version = "0.2.1+0" diff --git a/Project.toml b/Project.toml index 4078d9f0..f21c0145 100644 --- a/Project.toml +++ b/Project.toml @@ -15,6 +15,7 @@ Measures = "442fdcdd-2543-5da2-b0f3-8c86c306513e" NonlinearSolve = "8913a72c-1f9b-4ce2-8d82-65094dcecaec" Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a" Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +PreallocationTools = "d236fae5-4411-538c-8e31-a6e3d9e00b46" Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b" SharedArrays = "1a1011a3-84de-559e-8e89-a11a2f7dc383" StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" @@ -47,6 +48,7 @@ Measures = "0.3" NonlinearSolve = "4" Parameters = "0.12" Pkg = "1" +PreallocationTools = "0.4.25" Serialization = "1" SharedArrays = "1" StaticArrays = "1" diff --git a/examples/bench.jl b/examples/bench.jl index 5beeeebd..734d2a95 100644 --- a/examples/bench.jl +++ b/examples/bench.jl @@ -39,18 +39,18 @@ vel_app = [cos(alpha), 0.0, sin(alpha)] .* v_a set_va!(wa, vel_app) # Step 4: Initialize solvers for both LLT and VSM methods -llt_solver = Solver(aerodynamic_model_type=LLT) -vsm_solver = Solver(aerodynamic_model_type=VSM) +P = length(wa.panels) +llt_solver = Solver{P}(aerodynamic_model_type=LLT) +vsm_solver = Solver{P}(aerodynamic_model_type=VSM) # Step 5: Solve using both methods results_vsm = solve(vsm_solver, wa) sol = solve!(vsm_solver, wa) -results_vsm_base = solve_base(vsm_solver, wa) -println("Rectangular wing, solve_base:") -@time results_vsm_base = solve_base(vsm_solver, wa) -# time Python: 32.0 ms Ryzen 7950x -# time Julia: 0.6 ms Ryzen 7950x -# 0.8 ms laptop, performance mode, battery +results_vsm_base = solve_base!(vsm_solver, wa) +println("Rectangular wing, solve_base!:") +@time results_vsm_base = solve_base!(vsm_solver, wa) +# time Python: 32.0 ms Ryzen 7950x +# time Julia: 0.42 ms Ryzen 7950x println("Rectangular wing, solve!:") @time sol = solve!(vsm_solver, wa) println("Rectangular wing, solve:") @@ -61,7 +61,8 @@ wing = RamAirWing("data/ram_air_kite_body.obj", "data/ram_air_kite_foil.dat") body_aero = BodyAerodynamics([wing]) # Create solvers -vsm_solver = Solver( +P = length(wa.panels) +vsm_solver = Solver{P}( aerodynamic_model_type=VSM, is_with_artificial_damping=false ) @@ -81,8 +82,8 @@ set_va!(body_aero, vel_app) # Solving and plotting distributions results = solve(vsm_solver, body_aero) -results_base = solve_base(vsm_solver, body_aero) +results_base = solve_base!(vsm_solver, body_aero) println("RAM-air kite:") -@time results_base = solve_base(vsm_solver, body_aero) +@time results_base = solve_base!(vsm_solver, body_aero) nothing \ No newline at end of file diff --git a/examples/ram_air_kite.jl b/examples/ram_air_kite.jl index 93e72ce3..1aa53da8 100644 --- a/examples/ram_air_kite.jl +++ b/examples/ram_air_kite.jl @@ -24,7 +24,8 @@ if DEFORM end # Create solvers -vsm_solver = Solver( +P = length(body_aero.panels) +vsm_solver = Solver{P}( aerodynamic_model_type=VSM, is_with_artificial_damping=false ) diff --git a/examples/rectangular_wing.jl b/examples/rectangular_wing.jl index 318a3ada..27995a3a 100644 --- a/examples/rectangular_wing.jl +++ b/examples/rectangular_wing.jl @@ -35,8 +35,9 @@ vel_app = [cos(alpha), 0.0, sin(alpha)] .* v_a set_va!(wa, vel_app, [0, 0, 0.1]) # Step 4: Initialize solvers for both LLT and VSM methods -llt_solver = Solver(aerodynamic_model_type=LLT) -vsm_solver = Solver(aerodynamic_model_type=VSM) +P = length(wa.panels) +llt_solver = Solver{P}(aerodynamic_model_type=LLT) +vsm_solver = Solver{P}(aerodynamic_model_type=VSM) # Step 5: Solve using both methods results_llt = solve(llt_solver, wa) diff --git a/examples/stall_model.jl b/examples/stall_model.jl index 97c3b2a5..cd13a992 100644 --- a/examples/stall_model.jl +++ b/examples/stall_model.jl @@ -45,11 +45,12 @@ end body_aero_CAD_19ribs = BodyAerodynamics([CAD_wing]) # Create solvers -vsm_solver = Solver( +P = length(wa.panels) +vsm_solver = Solver{P}( aerodynamic_model_type=VSM, is_with_artificial_damping=false ) -VSM_with_stall_correction = Solver( +VSM_with_stall_correction = Solver{P}( aerodynamic_model_type=VSM, is_with_artificial_damping=true ) diff --git a/mwes/mwe_01.jl b/mwes/mwe_01.jl new file mode 100644 index 00000000..685696ff --- /dev/null +++ b/mwes/mwe_01.jl @@ -0,0 +1,63 @@ +# Replace va_norm_array = norm.(eachrow(solver.sol.va_array)) with a for loop + +# Testcase that shows that the new function is equivalent to the old, allocating line of code. +using Test +using LinearAlgebra # for the norm function + +# Define a mock Solver struct +struct MockSolver + sol::NamedTuple +end + +function calc_norm_array!(va_norm_array, va_array) + for i in 1:size(va_array, 1) + va_norm_array[i] = norm(view(va_array, i, :)) + end +end + +@testset "va_norm_array calculation" begin + global va_norm_array + + # Create a sample 2D array + sample_va_array = [ + 1.0 2.0 3.0; + 4.0 5.0 6.0; + 7.0 8.0 9.0 + ] + + # Create a mock solver with the sample array + mock_solver = MockSolver((va_array = sample_va_array,)) + + # Calculate va_norm_array + n = @allocated va_norm_array = norm.(eachrow(mock_solver.sol.va_array)) + println(n) + + va_norm_array2 = zeros(3) + m = @allocated calc_norm_array!(va_norm_array2, sample_va_array) + println(m) + + # Expected results (calculated manually) + expected_norms = [ + sqrt(1^2 + 2^2 + 3^2), + sqrt(4^2 + 5^2 + 6^2), + sqrt(7^2 + 8^2 + 9^2) + ] + + # Test the results + @test length(va_norm_array) == size(sample_va_array, 1) + @test va_norm_array ≈ expected_norms atol=1e-10 + + # Test individual values + @test va_norm_array[1] ≈ norm(sample_va_array[1, :]) atol=1e-10 + @test va_norm_array[2] ≈ norm(sample_va_array[2, :]) atol=1e-10 + @test va_norm_array[3] ≈ norm(sample_va_array[3, :]) atol=1e-10 + + @test length(va_norm_array2) == size(sample_va_array, 1) + @test va_norm_array2 ≈ expected_norms atol=1e-10 + + # Test individual values + @test va_norm_array2[1] ≈ norm(sample_va_array[1, :]) atol=1e-10 + @test va_norm_array2[2] ≈ norm(sample_va_array[2, :]) atol=1e-10 + @test va_norm_array2[3] ≈ norm(sample_va_array[3, :]) atol=1e-10 +end +nothing \ No newline at end of file diff --git a/mwes/mwe_02.jl b/mwes/mwe_02.jl new file mode 100644 index 00000000..142081ca --- /dev/null +++ b/mwes/mwe_02.jl @@ -0,0 +1,14 @@ + +# I tried to put a lazy cache (to avoid allocations for temporary vectors) +# into a struct. This does not work at all with the macro provided by the package +# Parameters. It works (no syntax error) with the macro Base.@kwdef, but if you +# make use of this cache it is extremely slow. +# +# This mwe can serve as starting point for further investigations. Currently the only +# cache that works is a cache in a global const variable. + +using PreallocationTools, Parameters + +Base.@kwdef mutable struct MockSolver + const ca::NTuple{11, LazyBufferCache{typeof(identity), typeof(identity)}} = ([LazyBufferCache() for _ in 1:11]) +end \ No newline at end of file diff --git a/src/VortexStepMethod.jl b/src/VortexStepMethod.jl index 7f5a3d04..76068db4 100644 --- a/src/VortexStepMethod.jl +++ b/src/VortexStepMethod.jl @@ -15,12 +15,13 @@ using Interpolations: Extrapolation using Parameters using Serialization using SharedArrays +using PreallocationTools using Pkg # Export public interface export Wing, Section, RamAirWing export BodyAerodynamics -export Solver, solve, solve_base, solve!, VSMSolution +export Solver, solve, solve_base!, solve!, VSMSolution export calculate_results export add_section!, set_va! export calculate_span, calculate_projected_area diff --git a/src/body_aerodynamics.jl b/src/body_aerodynamics.jl index cef76844..c4ce1346 100644 --- a/src/body_aerodynamics.jl +++ b/src/body_aerodynamics.jl @@ -297,16 +297,15 @@ Calculate Aerodynamic Influence Coefficient matrices. See also: [BodyAerodynamics](@ref), [Model](@ref) -Returns: - Tuple of (`AIC_x`, `AIC_y`, `AIC_z`) matrices +Returns: nothing """ -function calculate_AIC_matrices!(body_aero::BodyAerodynamics, model::Model, +@inline function calculate_AIC_matrices!(body_aero::BodyAerodynamics, model::Model, core_radius_fraction::Float64, va_norm_array::Vector{Float64}, va_unit_array::Matrix{Float64}) # Determine evaluation point based on model - evaluation_point = model === VSM ? :control_point : :aero_center - evaluation_point_on_bound = model === LLT + evaluation_point = model == VSM ? :control_point : :aero_center + evaluation_point_on_bound = model == LLT # Initialize AIC matrices velocity_induced, tempvel, va_unit, U_2D = zeros(MVec3), zeros(MVec3), zeros(MVec3), zeros(MVec3) @@ -330,13 +329,13 @@ function calculate_AIC_matrices!(body_aero::BodyAerodynamics, model::Model, core_radius_fraction, body_aero.work_vectors ) - body_aero.AIC[:, icp, jring] .= velocity_induced - + # Subtract 2D induced velocity for VSM - if icp == jring && model === VSM + if icp == jring && model == VSM calculate_velocity_induced_bound_2D!(U_2D, body_aero.panels[jring], ep, body_aero.work_vectors) - body_aero.AIC[:, icp, jring] .-= U_2D + velocity_induced .-= U_2D end + body_aero.AIC[:, icp, jring] .= velocity_induced end end return nothing @@ -347,24 +346,23 @@ end Calculate circulation distribution for an elliptical wing. -Returns: - Vector{Float64}: Circulation distribution along the wing +Returns: nothing """ -function calculate_circulation_distribution_elliptical_wing(body_aero::BodyAerodynamics, gamma_0::Float64=1.0) +function calculate_circulation_distribution_elliptical_wing(gamma_i, body_aero::BodyAerodynamics, gamma_0::Float64=1.0) length(body_aero.wings) == 1 || throw(ArgumentError("Multiple wings not yet implemented")) wing_span = body_aero.wings[1].span @debug "Wing span: $wing_span" # Calculate y-coordinates of control points + # TODO: pre-allocate y y = [panel.control_point[2] for panel in body_aero.panels] # Calculate elliptical distribution - gamma_i = gamma_0 * sqrt.(1 .- (2 .* y ./ wing_span).^2) + gamma_i .= gamma_0 * sqrt.(1 .- (2 .* y ./ wing_span).^2) @debug "Calculated circulation distribution: $gamma_i" - - return gamma_i + nothing end """ @@ -413,6 +411,8 @@ function calculate_stall_angle_list(panels::Vector{Panel}; return stall_angles end +const cache_body = [LazyBufferCache() for _ in 1:5] + """ update_effective_angle_of_attack_if_VSM(body_aero::BodyAerodynamics, gamma::Vector{Float64}, core_radius_fraction::Float64, @@ -427,7 +427,8 @@ Update angle of attack at aerodynamic center for VSM method. Returns: Vector{Float64}: Updated angles of attack """ -function update_effective_angle_of_attack_if_VSM(body_aero::BodyAerodynamics, +function update_effective_angle_of_attack!(alpha_corrected, + body_aero::BodyAerodynamics, gamma::Vector{Float64}, core_radius_fraction::Float64, z_airf_array::Matrix{Float64}, @@ -436,26 +437,53 @@ function update_effective_angle_of_attack_if_VSM(body_aero::BodyAerodynamics, va_norm_array::Vector{Float64}, va_unit_array::Matrix{Float64}) - # Calculate AIC matrices at aerodynamic center using LLT method - calculate_AIC_matrices!( - body_aero, LLT, core_radius_fraction, va_norm_array, va_unit_array - ) - AIC_x, AIC_y, AIC_z = @views body_aero.AIC[1, :, :], body_aero.AIC[2, :, :], body_aero.AIC[3, :, :] - - # Calculate induced velocities - induced_velocity = [ - AIC_x * gamma, - AIC_y * gamma, - AIC_z * gamma - ] - induced_velocity = hcat(induced_velocity...) + # Calculate AIC matrices (keep existing optimized view) + calculate_AIC_matrices!(body_aero, LLT, core_radius_fraction, va_norm_array, va_unit_array) + + # Get dimensions from existing data + n_rows = size(body_aero.AIC, 2) + n_cols = size(body_aero.AIC, 3) + + # Preallocate induced velocity array + induced_velocity = cache_body[1][va_array] + + # Calculate each component with explicit loops + for j in 1:3 # For each x/y/z component + for i in 1:n_rows + acc = zero(eltype(induced_velocity)) # Type-stable accumulator + for k in 1:n_cols + acc += body_aero.AIC[j, i, k] * gamma[k] + end + induced_velocity[i, j] = acc + end + end + + # In-place relative velocity calculation + relative_velocity = cache_body[2][va_array] + relative_velocity .= va_array .+ induced_velocity + + # Preallocate and compute dot products manually + n = size(relative_velocity, 1) + v_normal = cache_body[3][relative_velocity] + v_tangential = cache_body[4][relative_velocity] - # Calculate relative velocities and angles - relative_velocity = va_array + induced_velocity - v_normal = sum(z_airf_array .* relative_velocity, dims=2) - v_tangential = sum(x_airf_array .* relative_velocity, dims=2) - alpha_array = atan.(v_normal ./ v_tangential) - return alpha_array + @inbounds for i in 1:n + vn = 0.0 + vt = 0.0 + for j in 1:3 + vn += z_airf_array[i, j] * relative_velocity[i, j] + vt += x_airf_array[i, j] * relative_velocity[i, j] + end + v_normal[i] = vn + v_tangential[i] = vt + end + + # Direct angle calculation without temporary arrays + @inbounds for i in 1:n + alpha_corrected[i] = atan(v_normal[i], v_tangential[i]) + end + + nothing end """ @@ -501,6 +529,7 @@ function calculate_results( cd_array = zeros(n_panels) cm_array = zeros(n_panels) panel_width_array = zeros(n_panels) + alpha_corrected = zeros(n_panels) # Calculate coefficients for each panel for (i, panel) in enumerate(panels) @@ -515,8 +544,9 @@ function calculate_results( moment = reshape((cm_array .* 0.5 .* density .* v_a_array.^2 .* chord_array), :, 1) # Calculate alpha corrections based on model type - alpha_corrected = if aerodynamic_model_type === VSM - update_effective_angle_of_attack_if_VSM( + if aerodynamic_model_type === VSM + update_effective_angle_of_attack!( + alpha_corrected, body_aero, gamma_new, core_radius_fraction, @@ -526,10 +556,8 @@ function calculate_results( va_norm_array, va_unit_array ) - elseif aerodynamic_model_type === LLT - alpha_array - else - throw(ArgumentError("Unknown aerodynamic model type, should be LLT or VSM")) + elseif aerodynamic_model_type == LLT + alpha_corrected .= alpha_array end # Verify va is not distributed diff --git a/src/solver.jl b/src/solver.jl index 45fa2df6..2224e6c0 100644 --- a/src/solver.jl +++ b/src/solver.jl @@ -14,19 +14,52 @@ Struct for storing the solution of the [solve!](@ref) function. Must contain all - moment_coefficient_distribution::Vector{Float64}: Pitching moment coefficient around the spanwise vector of each panel. [-] - solver_status::SolverStatus: enum, see [SolverStatus](@ref) """ -mutable struct VSMSolution - gamma_distribution::Union{Nothing, Vector{Float64}} - aero_force::MVec3 - aero_moments::MVec3 - force_coefficients::MVec3 - moment_coefficients::MVec3 - moment_distribution::Vector{Float64} - moment_coefficient_distribution::Vector{Float64} - solver_status::SolverStatus +@with_kw mutable struct VSMSolution{P} + ### private vectors of solve_base! + x_airf_array::Matrix{Float64} = zeros(P, 3) + y_airf_array::Matrix{Float64} = zeros(P, 3) + z_airf_array::Matrix{Float64} = zeros(P, 3) + va_array::Matrix{Float64} = zeros(P, 3) + chord_array::Vector{Float64} = zeros(P) + ### + panel_width_array::Vector{Float64} = zeros(P) + cl_array::Vector{Float64} = zeros(P) + cd_array::Vector{Float64} = zeros(P) + cm_array::Vector{Float64} = zeros(P) + lift::Matrix{Float64} = zeros(P,1) + drag::Matrix{Float64} = zeros(P,1) + moment::Matrix{Float64} = zeros(P,1) + f_body_3D::Matrix{Float64} = zeros(3, P) + m_body_3D::Matrix{Float64} = zeros(3, P) + gamma_distribution::Union{Nothing, Vector{Float64}} = nothing + aero_force::MVec3 = zeros(MVec3) + aero_moments::MVec3 = zeros(MVec3) + force_coefficients::MVec3 = zeros(MVec3) + moment_coefficients::MVec3 = zeros(MVec3) + moment_distribution::Vector{Float64} = zeros(P) + moment_coefficient_distribution::Vector{Float64} = zeros(P) + solver_status::SolverStatus = FAILURE end -function VSMSolution() - VSMSolution(nothing, zeros(MVec3), zeros(MVec3), zeros(MVec3), zeros(MVec3), zeros(3), zeros(3), FAILURE) +function VSMSolution(P) + VSMSolution{P}() +end + +# Output of the function gamma_loop! +@with_kw mutable struct LoopResult{P} + converged::Bool = false + gamma_new::Vector{Float64} = zeros(P) + alpha_array::Vector{Float64} = zeros(P) # TODO: Is this different from BodyAerodynamics.alpha_array ? + v_a_array::Vector{Float64} = zeros(P) +end + +function LoopResult(P) + LoopResult{P}() +end + +@with_kw struct BaseResult{P} + va_norm_array::Vector{Float64} = zeros(P) + va_unit_array::Matrix{Float64} = zeros(P, 3) end """ @@ -57,7 +90,7 @@ Main solver structure for the Vortex Step Method.See also: [solve](@ref) ## Solution sol::VSMSolution = VSMSolution(): The result of calling [solve!](@ref) """ -@with_kw struct Solver +@with_kw struct Solver{P} # General settings aerodynamic_model_type::Model = VSM density::Float64 = 1.225 @@ -76,10 +109,23 @@ sol::VSMSolution = VSMSolution(): The result of calling [solve!](@ref) mu::Float64 = 1.81e-5 is_only_f_and_gamma_output::Bool = false + # Intermediate results + lr::LoopResult{P} = LoopResult(P) + br::BaseResult{P} = BaseResult{P}() + # Solution - sol::VSMSolution = VSMSolution() + sol::VSMSolution{P} = VSMSolution(P) +end + +function Solver(body_aero; kwargs) + P = length(body_aero.panels) + return Solver{P}(; kwargs...) end +const cache = [LazyBufferCache() for _ in 1:11] +const cache_base = [LazyBufferCache()] +const cache_solve = [LazyBufferCache()] + """ solve!(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution=solver.sol.gamma_distribution; log=false, reference_point=zeros(MVec3), moment_frac=0.1) @@ -105,10 +151,8 @@ function solve!(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution= log=false, reference_point=zeros(MVec3), moment_frac=0.1) # calculate intermediate result - (converged, body_aero, gamma_new, reference_point, density, aerodynamic_model_type, core_radius_fraction, - mu, alpha_array, v_a_array, chord_array, x_airf_array, y_airf_array, z_airf_array, - va_array, va_norm_array, va_unit_array, panels, - is_only_f_and_gamma_output) = solve_base(solver, body_aero, gamma_distribution; log, reference_point) + solve_base!(solver, body_aero, gamma_distribution; log, reference_point) + gamma_new = solver.lr.gamma_new if !isnothing(solver.sol.gamma_distribution) solver.sol.gamma_distribution .= gamma_new else @@ -116,15 +160,22 @@ function solve!(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution= end # Initialize arrays - n_panels = length(panels) - cl_array = zeros(n_panels) - cd_array = zeros(n_panels) - cm_array = zeros(n_panels) - panel_width_array = zeros(n_panels) - solver.sol.moment_distribution = zeros(n_panels) - solver.sol.moment_coefficient_distribution = zeros(n_panels) + cl_array = solver.sol.cl_array + cd_array = solver.sol.cd_array + cm_array = solver.sol.cm_array + converged = solver.lr.converged + alpha_array = solver.lr.alpha_array + alpha_corrected = cache_solve[1][alpha_array] + v_a_array = solver.lr.v_a_array + panels = body_aero.panels + + panel_width_array = solver.sol.panel_width_array + solver.sol.moment_distribution .= 0 + solver.sol.moment_coefficient_distribution .= 0 moment_distribution = solver.sol.moment_distribution moment_coefficient_distribution = solver.sol.moment_coefficient_distribution + density = solver.density + aerodynamic_model_type = solver.aerodynamic_model_type # Calculate coefficients for each panel for (i, panel) in enumerate(panels) # zero bytes @@ -133,53 +184,45 @@ function solve!(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution= panel_width_array[i] = panel.width end - # Calculate forces - lift = reshape((cl_array .* 0.5 .* density .* v_a_array.^2 .* chord_array), :, 1) # 336 bytes - drag = reshape((cd_array .* 0.5 .* density .* v_a_array.^2 .* chord_array), :, 1) - moment = reshape((cm_array .* 0.5 .* density .* v_a_array.^2 .* chord_array), :, 1) + # create an alias for the three vertical output vectors + lift = solver.sol.lift + drag = solver.sol.drag + moment = solver.sol.moment + + # Compute using fused broadcasting (no intermediate allocations) + @. lift = cl_array * 0.5 * density * v_a_array^2 * solver.sol.chord_array + @. drag = cd_array * 0.5 * density * v_a_array^2 * solver.sol.chord_array + @. moment = cm_array * 0.5 * density * v_a_array^2 * solver.sol.chord_array # Calculate alpha corrections based on model type - alpha_corrected = if aerodynamic_model_type == VSM # 4188 bytes - update_effective_angle_of_attack_if_VSM( + if aerodynamic_model_type == VSM # 64 bytes + update_effective_angle_of_attack!( + alpha_corrected, body_aero, gamma_new, - core_radius_fraction, - z_airf_array, - x_airf_array, - va_array, - va_norm_array, - va_unit_array + solver.core_radius_fraction, + solver.sol.z_airf_array, + solver.sol.x_airf_array, + solver.sol.va_array, + solver.br.va_norm_array, + solver.br.va_unit_array ) - elseif aerodynamic_model_type === LLT - alpha_array - else - throw(ArgumentError("Unknown aerodynamic model type, should be LLT or VSM")) + elseif aerodynamic_model_type == LLT + alpha_corrected .= alpha_array end # Initialize result arrays - # cl_prescribed_va = Float64[] - # cd_prescribed_va = Float64[] - # cs_prescribed_va = Float64[] - f_body_3D = zeros(3, n_panels) - m_body_3D = zeros(3, n_panels) area_all_panels = 0.0 - # Initialize force sums - lift_wing_3D_sum = 0.0 - drag_wing_3D_sum = 0.0 - side_wing_3D_sum = 0.0 - # Get wing properties spanwise_direction = body_aero.wings[1].spanwise_direction va_mag = norm(body_aero.va) - va = body_aero.va - va_unit = va / va_mag q_inf = 0.5 * density * va_mag^2 # Calculate wing geometry properties projected_area = body_aero.projected_area - for (i, panel) in enumerate(panels) # 30625 bytes + for (i, panel) in enumerate(panels) # 8000 bytes ### Lift and Drag ### # Panel geometry @@ -188,40 +231,23 @@ function solve!(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution= # Calculate induced velocity direction alpha_corrected_i = alpha_corrected[i] - induced_va_airfoil = cos(alpha_corrected_i) * panel.x_airf + - sin(alpha_corrected_i) * panel.z_airf - dir_induced_va_airfoil = induced_va_airfoil / norm(induced_va_airfoil) + dir_induced_va_airfoil = cos(alpha_corrected_i) * panel.x_airf + + sin(alpha_corrected_i) * panel.z_airf + normalize!(dir_induced_va_airfoil) # Calculate lift and drag directions - dir_lift_induced_va = cross(dir_induced_va_airfoil, panel.y_airf) - dir_lift_induced_va = dir_lift_induced_va / norm(dir_lift_induced_va) - dir_drag_induced_va = cross(spanwise_direction, dir_lift_induced_va) - dir_drag_induced_va = dir_drag_induced_va / norm(dir_drag_induced_va) + dir_lift_induced_va = dir_induced_va_airfoil × panel.y_airf + normalize!(dir_lift_induced_va) + dir_drag_induced_va = spanwise_direction × dir_lift_induced_va + normalize!(dir_drag_induced_va) # Calculate force vectors lift_induced_va = lift[i] * dir_lift_induced_va drag_induced_va = drag[i] * dir_drag_induced_va ftotal_induced_va = lift_induced_va + drag_induced_va - # # Calculate forces in prescribed wing frame - # dir_lift_prescribed_va = cross(va, spanwise_direction) - # dir_lift_prescribed_va = dir_lift_prescribed_va / norm(dir_lift_prescribed_va) - - # # Calculate force components - # lift_prescribed_va = dot(lift_induced_va, dir_lift_prescribed_va) + - # dot(drag_induced_va, dir_lift_prescribed_va) - # drag_prescribed_va = dot(lift_induced_va, va_unit) + - # dot(drag_induced_va, va_unit) - # side_prescribed_va = dot(lift_induced_va, spanwise_direction) + - # dot(drag_induced_va, spanwise_direction) - # Body frame forces - f_body_3D[:,i] .= ftotal_induced_va .* panel.width - - # # Update sums - # lift_wing_3D_sum += lift_prescribed_va * panel.width - # drag_wing_3D_sum += drag_prescribed_va * panel.width - # side_wing_3D_sum += side_prescribed_va * panel.width + solver.sol.f_body_3D[:,i] .= ftotal_induced_va .* panel.width # Calculate the moments # (1) Panel aerodynamic center in body frame: @@ -234,27 +260,27 @@ function solve!(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution= # Vector from panel AC to the chosen reference point: r_vector = panel_ac_body - reference_point # e.g. CG, wing root, etc. # Cross product to shift the force from panel AC to ref. point: - M_shift = cross(r_vector, f_body_3D[:,i]) + M_shift = r_vector × MVec3(solver.sol.f_body_3D[:,i]) # Total panel moment about the reference point: - m_body_3D[:,i] = M_local_3D + M_shift + solver.sol.m_body_3D[:,i] .= M_local_3D + M_shift # Calculate the moment distribution (moment on each panel) arm = (moment_frac - 0.25) * panel.chord - moment_distribution[i] = dot(ftotal_induced_va, panel.z_airf) * arm + moment_distribution[i] = (ftotal_induced_va ⋅ panel.z_airf) * arm moment_coefficient_distribution[i] = moment_distribution[i] / (q_inf * projected_area) end # update the result struct - solver.sol.aero_force .= [ - sum(f_body_3D[1,:]), - sum(f_body_3D[2,:]), - sum(f_body_3D[3,:]) - ] - solver.sol.aero_moments .= [ - sum(m_body_3D[1,:]), - sum(m_body_3D[2,:]), - sum(m_body_3D[3,:]) - ] + solver.sol.aero_force .= MVec3( + sum(solver.sol.f_body_3D[1,:]), + sum(solver.sol.f_body_3D[2,:]), + sum(solver.sol.f_body_3D[3,:]) + ) + solver.sol.aero_moments .= MVec3( + sum(solver.sol.m_body_3D[1,:]), + sum(solver.sol.m_body_3D[2,:]), + sum(solver.sol.m_body_3D[3,:]) + ) solver.sol.force_coefficients .= solver.sol.aero_force ./ (q_inf * projected_area) solver.sol.moment_coefficients .= solver.sol.aero_moments ./ (q_inf * projected_area) if converged @@ -289,36 +315,39 @@ A dictionary with the results. function solve(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution=nothing; log=false, reference_point=zeros(MVec3)) # calculate intermediate result - converged, - body_aero, gamma_new, reference_point, density, aerodynamic_model_type, core_radius_fraction, - mu, alpha_array, v_a_array, chord_array, x_airf_array, y_airf_array, z_airf_array, - va_array, va_norm_array, va_unit_array, panels, - is_only_f_and_gamma_output = solve_base(solver, body_aero, gamma_distribution; log, reference_point) + solve_base!(solver, body_aero, gamma_distribution; log, reference_point) # Calculate final results as dictionary results = calculate_results( body_aero, - gamma_new, + solver.lr.gamma_new, reference_point, - density, - aerodynamic_model_type, - core_radius_fraction, - mu, - alpha_array, - v_a_array, - chord_array, - x_airf_array, - y_airf_array, - z_airf_array, - va_array, - va_norm_array, - va_unit_array, - panels, - is_only_f_and_gamma_output + solver.density, + solver.aerodynamic_model_type, + solver.core_radius_fraction, + solver.mu, + solver.lr.alpha_array, + solver.lr.v_a_array, + solver.sol.chord_array, + solver.sol.x_airf_array, + solver.sol.y_airf_array, + solver.sol.z_airf_array, + solver.sol.va_array, + solver.br.va_norm_array, + solver.br.va_unit_array, + body_aero.panels, + solver.is_only_f_and_gamma_output ) return results end -function solve_base(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution=nothing; + +@inline @inbounds function calc_norm_array!(va_norm_array, va_array) + for i in 1:size(va_array, 1) + va_norm_array[i] = norm(MVec3(view(va_array, i, :))) + end +end + +function solve_base!(solver::Solver, body_aero::BodyAerodynamics, gamma_distribution=nothing; log=false, reference_point=zeros(MVec3)) # check arguments @@ -327,148 +356,95 @@ function solve_base(solver::Solver, body_aero::BodyAerodynamics, gamma_distribut # Initialize variables panels = body_aero.panels n_panels = length(panels) - alpha_array = body_aero.alpha_array relaxation_factor = solver.relaxation_factor - # Preallocate arrays - x_airf_array = zeros(n_panels, 3) - y_airf_array = zeros(n_panels, 3) - z_airf_array = zeros(n_panels, 3) - va_array = zeros(n_panels, 3) - chord_array = zeros(n_panels) + # Clear arrays + solver.sol.x_airf_array .= 0 + solver.sol.y_airf_array .= 0 + solver.sol.z_airf_array .= 0 + solver.sol.va_array .= 0 + solver.sol.chord_array .= 0 # Fill arrays from panels for (i, panel) in enumerate(panels) - x_airf_array[i, :] .= panel.x_airf - y_airf_array[i, :] .= panel.y_airf - z_airf_array[i, :] .= panel.z_airf - va_array[i, :] .= panel.va - chord_array[i] = panel.chord + solver.sol.x_airf_array[i, :] .= panel.x_airf + solver.sol.y_airf_array[i, :] .= panel.y_airf + solver.sol.z_airf_array[i, :] .= panel.z_airf + solver.sol.va_array[i, :] .= panel.va + solver.sol.chord_array[i] = panel.chord end # Calculate unit vectors - va_norm_array = norm.(eachrow(va_array)) - va_unit_array = va_array ./ va_norm_array + calc_norm_array!(solver.br.va_norm_array, solver.sol.va_array) + solver.br.va_unit_array .= solver.sol.va_array ./ solver.br.va_norm_array # Calculate AIC matrices - calculate_AIC_matrices!( - body_aero, - solver.aerodynamic_model_type, - solver.core_radius_fraction, - va_norm_array, - va_unit_array - ) + calculate_AIC_matrices!(body_aero, solver.aerodynamic_model_type, solver.core_radius_fraction, solver.br.va_norm_array, + solver.br.va_unit_array) # Initialize gamma distribution - gamma_initial = if isnothing(gamma_distribution) + gamma_initial = cache_base[1][solver.sol.chord_array] + if isnothing(gamma_distribution) if solver.type_initial_gamma_distribution === :elliptic - calculate_circulation_distribution_elliptical_wing(body_aero) + calculate_circulation_distribution_elliptical_wing(gamma_initial, body_aero) else - zeros(n_panels) + gamma_initial .= 0 end else length(gamma_distribution) == n_panels || throw(ArgumentError("gamma_distribution length must match number of panels")) - gamma_distribution + gamma_initial .= gamma_distribution end @debug "Initial gamma_new: $gamma_initial" + solver.lr.gamma_new .= gamma_initial # Run main iteration loop - converged, gamma_new, alpha_array, v_a_array = gamma_loop( - solver, - body_aero, - gamma_initial, - va_array, - chord_array, - x_airf_array, - y_airf_array, - z_airf_array, - panels, - relaxation_factor; - log - ) + gamma_loop!(solver, body_aero, panels, relaxation_factor; log) # Try again with reduced relaxation factor if not converged - if !converged && relaxation_factor > 1e-3 + if ! solver.lr.converged && relaxation_factor > 1e-3 log && @warn "Running again with half the relaxation_factor = $(relaxation_factor/2)" - converged, gamma_new, alpha_array, v_a_array = gamma_loop( - solver, - body_aero, - gamma_initial, - va_array, - chord_array, - x_airf_array, - y_airf_array, - z_airf_array, - panels, - relaxation_factor/2; - log - ) + solver.lr.gamma_new .= gamma_initial + gamma_loop!(solver, body_aero, panels, relaxation_factor/2; log) end - # Return results - return ( - converged, - body_aero, - gamma_new, - reference_point, - solver.density, - solver.aerodynamic_model_type, - solver.core_radius_fraction, - solver.mu, - alpha_array, - v_a_array, - chord_array, - x_airf_array, - y_airf_array, - z_airf_array, - va_array, - va_norm_array, - va_unit_array, - panels, - solver.is_only_f_and_gamma_output - ) + nothing end -cross3(x,y) = cross(SVector{3,eltype(x)}(x), SVector{3,eltype(y)}(y)) - """ - gamma_loop(solver::Solver, gamma_new::Vector{Float64}, AIC_x::Matrix{Float64}, - AIC_y::Matrix{Float64}, AIC_z::Matrix{Float64}, va_array::Matrix{Float64}, - chord_array::Vector{Float64}, x_airf_array::Matrix{Float64}, - y_airf_array::Matrix{Float64}, z_airf_array::Matrix{Float64}, + gamma_loop!(solver::Solver, AIC_x::Matrix{Float64}, + AIC_y::Matrix{Float64}, AIC_z::Matrix{Float64}, panels::Vector{Panel}, relaxation_factor::Float64; log=true) Main iteration loop for calculating circulation distribution. """ -function gamma_loop( +function gamma_loop!( solver::Solver, body_aero::BodyAerodynamics, - gamma_new::Vector{Float64}, - va_array::Matrix{Float64}, - chord_array::Vector{Float64}, - x_airf_array::Matrix{Float64}, - y_airf_array::Matrix{Float64}, - z_airf_array::Matrix{Float64}, panels::Vector{Panel}, relaxation_factor::Float64; log::Bool = true ) - converged = false - n_panels = length(body_aero.panels) - alpha_array = body_aero.alpha_array - v_a_array = body_aero.v_a_array - Umagw_array = similar(v_a_array) - - gamma = copy(gamma_new) - abs_gamma_new = copy(gamma_new) - induced_velocity_all = zeros(n_panels, 3) - relative_velocity_array = similar(va_array) - relative_velocity_crossz = similar(relative_velocity_array) - v_acrossz_array = similar(va_array) - cl_array = zeros(n_panels) - damp = zeros(length(gamma)) - v_normal_array = zeros(n_panels) - v_tangential_array = zeros(n_panels) + va_array = solver.sol.va_array + chord_array = solver.sol.chord_array + x_airf_array = solver.sol.x_airf_array + y_airf_array = solver.sol.y_airf_array + z_airf_array = solver.sol.z_airf_array + solver.lr.converged = false + n_panels = length(body_aero.panels) + solver.lr.alpha_array .= body_aero.alpha_array + solver.lr.v_a_array .= body_aero.v_a_array + va_magw_array = cache[1][solver.lr.v_a_array] + + gamma = cache[2][solver.lr.gamma_new] + abs_gamma_new = cache[3][solver.lr.gamma_new] + induced_velocity_all = cache[4][va_array] + relative_velocity_array = cache[5][va_array] + relative_velocity_crossz = cache[6][va_array] + v_acrossz_array = cache[7][va_array] + cl_array = cache[8][gamma] + damp = cache[9][cl_array] + v_normal_array = cache[10][cl_array] + v_tangential_array = cache[11][v_normal_array] AIC_x, AIC_y, AIC_z = body_aero.AIC[1, :, :], body_aero.AIC[2, :, :], body_aero.AIC[3, :, :] @@ -479,7 +455,7 @@ function gamma_loop( iters = 0 for i in 1:solver.max_iterations iters += 1 - gamma .= gamma_new + gamma .= solver.lr.gamma_new # Calculate induced velocities mul!(velocity_view_x, AIC_x, gamma) @@ -488,31 +464,27 @@ function gamma_loop( relative_velocity_array .= va_array .+ induced_velocity_all for i in 1:n_panels - relative_velocity_crossz[i, :] .= cross3( - view(relative_velocity_array, i, :), - view(y_airf_array, i, :) - ) - v_acrossz_array[i, :] .= cross3( - view(va_array, i, :), - view(y_airf_array, i, :) - ) + relative_velocity_crossz[i, :] .= MVec3(view(relative_velocity_array, i, :)) × + MVec3(view(y_airf_array, i, :)) + v_acrossz_array[i, :] .= MVec3(view(va_array, i, :)) × + MVec3(view(y_airf_array, i, :)) end for i in 1:n_panels - v_normal_array[i] = dot(view(z_airf_array, i, :), view(relative_velocity_array, i, :)) - v_tangential_array[i] = dot(view(x_airf_array, i, :), view(relative_velocity_array, i, :)) + v_normal_array[i] = view(z_airf_array, i, :) ⋅ view(relative_velocity_array, i, :) + v_tangential_array[i] = view(x_airf_array, i, :) ⋅ view(relative_velocity_array, i, :) end - alpha_array .= atan.(v_normal_array, v_tangential_array) + solver.lr.alpha_array .= atan.(v_normal_array, v_tangential_array) for i in 1:n_panels - @views v_a_array[i] = norm(relative_velocity_crossz[i, :]) - @views Umagw_array[i] = norm(v_acrossz_array[i, :]) + @views solver.lr.v_a_array[i] = norm(relative_velocity_crossz[i, :]) + @views va_magw_array[i] = norm(v_acrossz_array[i, :]) end - for (i, (panel, alpha)) in enumerate(zip(panels, alpha_array)) + for (i, (panel, alpha)) in enumerate(zip(panels, solver.lr.alpha_array)) cl_array[i] = calculate_cl(panel, alpha) end - gamma_new .= 0.5 .* v_a_array.^2 ./ Umagw_array .* cl_array .* chord_array + solver.lr.gamma_new .= 0.5 .* solver.lr.v_a_array.^2 ./ va_magw_array .* cl_array .* chord_array # Apply damping if needed if solver.is_with_artificial_damping @@ -523,32 +495,32 @@ function gamma_loop( is_damping_applied = false end # Update gamma with relaxation and damping - gamma_new .= (1 - relaxation_factor) .* gamma .+ - relaxation_factor .* gamma_new .+ damp + solver.lr.gamma_new .= (1 - relaxation_factor) .* gamma .+ + relaxation_factor .* solver.lr.gamma_new .+ damp # Check convergence - abs_gamma_new .= abs.(gamma_new) + abs_gamma_new .= abs.(solver.lr.gamma_new) reference_error = maximum(abs_gamma_new) reference_error = max(reference_error, solver.tol_reference_error) - abs_gamma_new .= abs.(gamma_new .- gamma) + abs_gamma_new .= abs.(solver.lr.gamma_new .- gamma) error = maximum(abs_gamma_new) normalized_error = error / reference_error @debug "Iteration: $i, normalized_error: $normalized_error, is_damping_applied: $is_damping_applied" if normalized_error < solver.allowed_error - converged = true + solver.lr.converged = true break end end - if log && converged + if log && solver.lr.converged @info "Converged after $iters iterations" elseif log @warn "NO convergence after $(solver.max_iterations) iterations" end - return converged, gamma_new, alpha_array, v_a_array + nothing end """ diff --git a/test/bench.jl b/test/bench.jl index bd1d8a14..1435406c 100644 --- a/test/bench.jl +++ b/test/bench.jl @@ -6,8 +6,8 @@ end using BenchmarkTools using StaticArrays using VortexStepMethod -using VortexStepMethod: calculate_AIC_matrices!, gamma_loop, calculate_results, - update_effective_angle_of_attack_if_VSM, calculate_projected_area, +using VortexStepMethod: calculate_AIC_matrices!, gamma_loop!, calculate_results, + update_effective_angle_of_attack!, calculate_projected_area, calculate_cl, calculate_cd_cm, calculate_velocity_induced_single_ring_semiinfinite!, calculate_velocity_induced_bound_2D!, @@ -44,7 +44,8 @@ using LinearAlgebra set_va!(body_aero, vel_app) # Initialize solvers for both LLT and VSM methods - solver = Solver() + P = length(body_aero.panels) + solver = Solver{P}() # Pre-allocate arrays gamma = rand(n_panels) @@ -112,24 +113,24 @@ using LinearAlgebra aero_model, aero_data) body_aero = BodyAerodynamics([wing]) - - solver = Solver( + + P = length(body_aero.panels) + solver = Solver{P}( aerodynamic_model_type=model ) - result = @benchmark gamma_loop( + solver.sol.va_array .= va_array + solver.sol.chord_array .= chord_array + solver.sol.x_airf_array .= x_airf_array + solver.sol.y_airf_array .= y_airf_array + solver.sol.z_airf_array .= z_airf_array + result = @benchmark gamma_loop!( $solver, $body_aero, - $gamma_new, - $va_array, - $chord_array, - $x_airf_array, - $y_airf_array, - $z_airf_array, $body_aero.panels, 0.5; log = false ) samples = 1 evals = 1 - @test result.allocs ≤ 100 + @test result.allocs ≤ 10 @info "Model: $model \t Aero_model: $aero_model \t Allocations: $(result.allocs) Memory: $(result.memory)" end end diff --git a/test/bench2.jl b/test/bench2.jl new file mode 100644 index 00000000..55fe4947 --- /dev/null +++ b/test/bench2.jl @@ -0,0 +1,52 @@ +using LinearAlgebra +using VortexStepMethod +using BenchmarkTools + +using Pkg + +if !("CSV" ∈ keys(Pkg.project().dependencies)) + using TestEnv + TestEnv.activate() +end + +# Step 1: Define wing parameters +n_panels = 20 # Number of panels +span = 20.0 # Wing span [m] +chord = 1.0 # Chord length [m] +v_a = 20.0 # Magnitude of inflow velocity [m/s] +density = 1.225 # Air density [kg/m³] +alpha_deg = 30.0 # Angle of attack [degrees] +alpha = deg2rad(alpha_deg) + +# Step 2: Create wing geometry with linear panel distribution +wing = Wing(n_panels, spanwise_panel_distribution=LINEAR) + +# Add wing sections - defining only tip sections with inviscid airfoil model +add_section!(wing, + [0.0, span/2, 0.0], # Left tip LE + [chord, span/2, 0.0], # Left tip TE + INVISCID) +add_section!(wing, + [0.0, -span/2, 0.0], # Right tip LE + [chord, -span/2, 0.0], # Right tip TE + INVISCID) + +# Step 3: Initialize aerodynamics +wa = BodyAerodynamics([wing]) + +# Set inflow conditions +vel_app = [cos(alpha), 0.0, sin(alpha)] .* v_a +set_va!(wa, vel_app) + +# Step 4: Initialize solvers for both LLT and VSM methods +P = length(wa.panels) +vsm_solver = Solver{P}(aerodynamic_model_type=VSM) + +# Step 5: Solve using both methods +println("Rectangular wing, solve_base!:") +@btime solve_base!($vsm_solver, $wa, nothing) # 34 allocations +# time Python: 32.0 ms Ryzen 7950x +# time Julia: 0.45 ms Ryzen 7950x +println("Rectangular wing, solve!:") +@btime sol = solve!($vsm_solver, $wa, nothing) # 328 allocations +nothing \ No newline at end of file diff --git a/test/test_body_aerodynamics.jl b/test/test_body_aerodynamics.jl index 827e3ae1..d30f738c 100644 --- a/test/test_body_aerodynamics.jl +++ b/test/test_body_aerodynamics.jl @@ -145,7 +145,8 @@ end set_va!(body_aero, v_a) # Run analysis - solver_object = Solver( + P = length(body_aero.panels) + solver_object = Solver{P}( aerodynamic_model_type=model, core_radius_fraction=core_radius_fraction ) diff --git a/test/test_plotting.jl b/test/test_plotting.jl index 02077e8d..c5104c4b 100644 --- a/test/test_plotting.jl +++ b/test/test_plotting.jl @@ -63,8 +63,9 @@ plt.ioff() rm("/tmp/Rectangular_wing_geometry_top_view.pdf") # Step 5: Initialize the solvers - vsm_solver = Solver(aerodynamic_model_type=VSM) - llt_solver = Solver(aerodynamic_model_type=LLT) + P = length(body_aero.panels) + vsm_solver = Solver{P}(aerodynamic_model_type=VSM) + llt_solver = Solver{P}(aerodynamic_model_type=LLT) # Step 6: Solve the VSM and LLT results_vsm = solve(vsm_solver, body_aero)