From 984a350b250b972eb7cbd56147f4566cf5579d06 Mon Sep 17 00:00:00 2001 From: Vasily Ilin Date: Sat, 6 Jan 2024 13:53:47 -0800 Subject: [PATCH 1/2] Fix the method ambiguities in `spatial_massaction_jump.jl`. --- src/spatial/spatial_massaction_jump.jl | 82 ++++++-------------------- 1 file changed, 18 insertions(+), 64 deletions(-) diff --git a/src/spatial/spatial_massaction_jump.jl b/src/spatial/spatial_massaction_jump.jl index 34504f1b8..e85b8f33f 100644 --- a/src/spatial/spatial_massaction_jump.jl +++ b/src/spatial/spatial_massaction_jump.jl @@ -19,10 +19,12 @@ struct SpatialMassActionJump{A <: AVecOrNothing, B <: AMatOrNothing, S, U, V} <: nocopy::Bool) where {A <: AVecOrNothing, B <: AMatOrNothing, S, U, V} - uniform_rates = (nocopy || isnothing(uniform_rates)) ? uniform_rates : - copy(uniform_rates) - spatial_rates = (nocopy || isnothing(spatial_rates)) ? spatial_rates : - copy(spatial_rates) + uniform_rates = isnothing(uniform_rates) ? Vector{Float64}(undef, 0) : uniform_rates + spatial_rates = isnothing(spatial_rates) ? Matrix{Float64}(undef, 0, 0) : spatial_rates + + uniform_rates = nocopy ? uniform_rates : copy(uniform_rates) + spatial_rates = nocopy ? spatial_rates : copy(spatial_rates) + reactant_stoch = nocopy ? reactant_stoch : copy(reactant_stoch) for i in eachindex(reactant_stoch) if useiszero && (length(reactant_stoch[i]) == 1) && @@ -30,11 +32,11 @@ struct SpatialMassActionJump{A <: AVecOrNothing, B <: AMatOrNothing, S, U, V} <: reactant_stoch[i] = typeof(reactant_stoch[i])() end end - num_unif_rates = isnothing(uniform_rates) ? 0 : length(uniform_rates) + num_unif_rates = length(uniform_rates) if scale_rates && num_unif_rates > 0 scalerates!(uniform_rates, reactant_stoch) end - if scale_rates && !isnothing(spatial_rates) && !isempty(spatial_rates) + if scale_rates && !isempty(spatial_rates) scalerates!(spatial_rates, reactant_stoch[(num_unif_rates + 1):end]) end new(uniform_rates, spatial_rates, reactant_stoch, net_stoch, param_mapper) @@ -43,66 +45,27 @@ end ################ Constructors ################## -function SpatialMassActionJump(urates::A, srates::B, rs::S, ns::U, pmapper::V; +function SpatialMassActionJump(urates::A, srates::B, rs, ns, pmapper = nothing; scale_rates = true, useiszero = true, - nocopy = false) where {A <: AVecOrNothing, - B <: AMatOrNothing, S, U, V} - SpatialMassActionJump{A, B, S, U, V}(urates, srates, rs, ns, pmapper, scale_rates, - useiszero, nocopy) -end -function SpatialMassActionJump(urates::A, srates::B, rs, ns; scale_rates = true, - useiszero = true, nocopy = false) where {A <: AVecOrNothing, B <: AMatOrNothing} - SpatialMassActionJump(urates, srates, rs, ns, nothing; scale_rates = scale_rates, - useiszero = useiszero, nocopy = nocopy) -end - -function SpatialMassActionJump(srates::B, rs, ns, pmapper; scale_rates = true, - useiszero = true, - nocopy = false) where {B <: AMatOrNothing} - SpatialMassActionJump(nothing, srates, rs, ns, pmapper; scale_rates = scale_rates, - useiszero = useiszero, nocopy = nocopy) -end -function SpatialMassActionJump(srates::B, rs, ns; scale_rates = true, useiszero = true, - nocopy = false) where {B <: AMatOrNothing} - SpatialMassActionJump(nothing, srates, rs, ns, nothing; scale_rates = scale_rates, - useiszero = useiszero, nocopy = nocopy) + SpatialMassActionJump(urates, srates, rs, ns, pmapper, scale_rates, + useiszero, nocopy) end - -function SpatialMassActionJump(urates::A, rs, ns, pmapper; scale_rates = true, - useiszero = true, - nocopy = false) where {A <: AVecOrNothing} - SpatialMassActionJump(urates, nothing, rs, ns, pmapper; scale_rates = scale_rates, - useiszero = useiszero, nocopy = nocopy) +function SpatialMassActionJump(srates::AbstractMatrix, rs, ns, pmapper = nothing; kwargs...) + SpatialMassActionJump(nothing, srates, rs, ns, pmapper; kwargs...) end -function SpatialMassActionJump(urates::A, rs, ns; scale_rates = true, useiszero = true, - nocopy = false) where {A <: AVecOrNothing} - SpatialMassActionJump(urates, nothing, rs, ns, nothing; scale_rates = scale_rates, - useiszero = useiszero, nocopy = nocopy) +function SpatialMassActionJump(urates::AbstractVector, rs::AbstractVector, ns, pmapper = nothing; kwargs...) + SpatialMassActionJump(urates, nothing, rs, ns, pmapper; kwargs...) end - -function SpatialMassActionJump(ma_jumps::MassActionJump{T, S, U, V}; scale_rates = true, - useiszero = true, nocopy = false) where {T, S, U, V} +function SpatialMassActionJump(ma_jumps::M; kwargs...) where {M <: MassActionJump} SpatialMassActionJump(ma_jumps.scaled_rates, ma_jumps.reactant_stoch, ma_jumps.net_stoch, ma_jumps.param_mapper; - scale_rates = scale_rates, useiszero = useiszero, nocopy = nocopy) + kwargs...) end ############################################## -function get_num_majumps(smaj::SpatialMassActionJump{Nothing, Nothing, S, U, V}) where - {S, U, V} - 0 -end -function get_num_majumps(smaj::SpatialMassActionJump{Nothing, B, S, U, V}) where - {B, S, U, V} - size(smaj.spatial_rates, 1) -end -function get_num_majumps(smaj::SpatialMassActionJump{A, Nothing, S, U, V}) where - {A, S, U, V} - length(smaj.uniform_rates) -end function get_num_majumps(smaj::SpatialMassActionJump{A, B, S, U, V}) where {A <: AbstractVector, B <: AbstractMatrix, S, U, V} length(smaj.uniform_rates) + size(smaj.spatial_rates, 1) @@ -110,16 +73,7 @@ end using_params(smaj::SpatialMassActionJump) = false function rate_at_site(rx, site, - smaj::SpatialMassActionJump{Nothing, B, S, U, V}) where {B, S, U, V} - smaj.spatial_rates[rx, site] -end -function rate_at_site(rx, site, - smaj::SpatialMassActionJump{A, Nothing, S, U, V}) where {A, S, U, V} - smaj.uniform_rates[rx] -end -function rate_at_site(rx, site, - smaj::SpatialMassActionJump{A, B, S, U, V}) where - {A <: AbstractVector, B <: AbstractMatrix, S, U, V} + smaj::SpatialMassActionJump) num_unif_rxs = length(smaj.uniform_rates) rx <= num_unif_rxs ? smaj.uniform_rates[rx] : smaj.spatial_rates[rx - num_unif_rxs, site] From c621810812784ef7323954befa35a6400d848005 Mon Sep 17 00:00:00 2001 From: Vasily Ilin Date: Sun, 7 Jan 2024 00:05:25 -0800 Subject: [PATCH 2/2] Fix flattening. --- src/spatial/flatten.jl | 6 +----- src/spatial/spatial_massaction_jump.jl | 22 ++++++++-------------- 2 files changed, 9 insertions(+), 19 deletions(-) diff --git a/src/spatial/flatten.jl b/src/spatial/flatten.jl index 4a5e7a1b3..0b3ed82c6 100644 --- a/src/spatial/flatten.jl +++ b/src/spatial/flatten.jl @@ -18,11 +18,7 @@ function flatten(ma_jump, prob::DiscreteProblem, spatial_system, hopping_constan rx_rates = ma_jump.scaled_rates elseif isa(ma_jump, SpatialMassActionJump) num_nodes = num_sites(spatial_system) - if isnothing(ma_jump.uniform_rates) && isnothing(ma_jump.spatial_rates) - rx_rates = zeros(0, num_nodes) - elseif isnothing(ma_jump.uniform_rates) - rx_rates = ma_jump.spatial_rates - elseif isnothing(ma_jump.spatial_rates) + if isempty(ma_jump.spatial_rates) rx_rates = reshape(repeat(ma_jump.uniform_rates, num_nodes), length(ma_jump.uniform_rates), num_nodes) else diff --git a/src/spatial/spatial_massaction_jump.jl b/src/spatial/spatial_massaction_jump.jl index e85b8f33f..6b1e111c8 100644 --- a/src/spatial/spatial_massaction_jump.jl +++ b/src/spatial/spatial_massaction_jump.jl @@ -1,7 +1,4 @@ -const AVecOrNothing = Union{AbstractVector, Nothing} -const AMatOrNothing = Union{AbstractMatrix, Nothing} - -struct SpatialMassActionJump{A <: AVecOrNothing, B <: AMatOrNothing, S, U, V} <: +struct SpatialMassActionJump{A <: AbstractVector, B <: AbstractMatrix, S, U, V} <: AbstractMassActionJump uniform_rates::A # reactions that are uniform in space spatial_rates::B # reactions whose rate depends on the site @@ -16,12 +13,9 @@ struct SpatialMassActionJump{A <: AVecOrNothing, B <: AMatOrNothing, S, U, V} <: reactant_stoch::S, net_stoch::U, param_mapper::V, scale_rates::Bool, useiszero::Bool, - nocopy::Bool) where {A <: AVecOrNothing, - B <: AMatOrNothing, + nocopy::Bool) where {A <: AbstractVector, + B <: AbstractMatrix, S, U, V} - uniform_rates = isnothing(uniform_rates) ? Vector{Float64}(undef, 0) : uniform_rates - spatial_rates = isnothing(spatial_rates) ? Matrix{Float64}(undef, 0, 0) : spatial_rates - uniform_rates = nocopy ? uniform_rates : copy(uniform_rates) spatial_rates = nocopy ? spatial_rates : copy(spatial_rates) @@ -47,16 +41,16 @@ end function SpatialMassActionJump(urates::A, srates::B, rs, ns, pmapper = nothing; scale_rates = true, useiszero = true, - nocopy = false) where {A <: AVecOrNothing, - B <: AMatOrNothing} - SpatialMassActionJump(urates, srates, rs, ns, pmapper, scale_rates, + nocopy = false) where {A <: AbstractVector, + B <: AbstractMatrix} + SpatialMassActionJump{A, B, typeof(rs), typeof(ns), typeof(pmapper)}(urates, srates, rs, ns, pmapper, scale_rates, useiszero, nocopy) end function SpatialMassActionJump(srates::AbstractMatrix, rs, ns, pmapper = nothing; kwargs...) - SpatialMassActionJump(nothing, srates, rs, ns, pmapper; kwargs...) + SpatialMassActionJump(Vector{eltype(srates)}(undef, 0), srates, rs, ns, pmapper; kwargs...) end function SpatialMassActionJump(urates::AbstractVector, rs::AbstractVector, ns, pmapper = nothing; kwargs...) - SpatialMassActionJump(urates, nothing, rs, ns, pmapper; kwargs...) + SpatialMassActionJump(urates, Matrix{eltype(urates)}(undef, 0, 0), rs, ns, pmapper; kwargs...) end function SpatialMassActionJump(ma_jumps::M; kwargs...) where {M <: MassActionJump} SpatialMassActionJump(ma_jumps.scaled_rates, ma_jumps.reactant_stoch,