StockFlow

define the sub-schema of c0, which includes the three objects: stocks(S), sum-auxiliary-variables(SV), and the linkages between them (LS) to be composed

define the schema of a general stock and flow diagram

define the schema of a general stock and flow diagram, not includes the functions of auxiliary variables

define the schema of a general stock and flow diagram

CausalLoop(ns,es)

Create causal loop diagram from collection of nodes and collection of edges.

StockAndFlow0(s,sv,ssv)

for an instance of the sub-schema, the program supports only have stocks, or only have sum auxiliary variables, or both stocks and sum auxiliary variables, or have both

StockAndFlowF(s,p,v,f,sv)

EXAMPLE: when define the dynamical variables, need to define with the correct order

sir_StockAndFlow=StockAndFlowF((:S=>(:F_NONE,:inf,:N), :I=>(:inf,:F_NONE,:N)),
 (:c, :beta),
 (:v_prevalence=>(:I,:N,:/),:v_meanInfectiousContactsPerS=>(:c,:v_prevalence,:*),:v_perSIncidenceRate=>(:beta,:v_meanInfectiousContactsPerS,:*),:v_newInfetions=>(:S,:v_perSIncidenceRate,:*)),
 (:inf=>:v_newInfetions),
 (:N))

add_prefix!(sf::AbstractStockAndFlowStructureF, prefix)

Modify a AbstractStockAndFlowStructureF so named elements begin with prefix Prefix can be anything which can be cast to a Symbol.For feet.

add_prefix!(sf::AbstractStockAndFlowStructureF, prefix)

Modify a AbstractStockAndFlowStructureF so named elements begin with prefix Prefix can be anything which can be cast to a Symbol.

add_suffix!(sf::AbstractStockAndFlow0, suffix)

Modify a AbstractStockAndFlow0 so named elements end with suffix. Suffix can be anything which can be cast to a Symbol. For feet.

add_suffix!(sf::AbstractStockAndFlow0, suffix)

Modify a AbstractStockAndFlow0 so named elements end with suffix. Suffix can be anything which can be cast to a Symbol.

args(p::AbstractStockAndFlowF,v)

Return a Vector of Symbols of flattened stocks, sums, parameters and source dynamic variables a dynamic variable at index v links to.

args(p::AbstractStockAndFlowStructureF,v)

Return a Vector of Symbols of flattened stocks, sums, parameters and source dynamic variables a dynamic variable at index v links to.

Return a Tuple of Vectors of Symbols of flattened stocks, sums, parameters and source dynamic variables a dynamic variable at index v links to.

Return a new StockAndFlowStructureF with flattened names, operators and positions from an AbstractStockAndFlowF.

Return a new stock flow with flattened names, operators and positions from an AbstractStockAndFlowStructureF. Need to provide dynamic variable definitions, eg

convertSystemStructureToStockFlow(MyStockFlowStructure, (:v_prevalence=>(:I,:N,:/),:v_meanInfectiousContactsPerS=>(:c,:v_prevalence,:*)))

Convert StockFlow to CLD. Nodes: stocks, flows, sum variables, parameters, nonflow dynamic variables Edges: morphisms in stock flow

Return flow names as Symbol, along with the linked flow variables

Return parameter names as Symbol

Return stock names as Symbol, along with the linked flows and sum variables

Return sum variable names as Symbol, along with the linked dynamic variables

Convert dynamic variable names to Symbol, convert all operators to a single operator if they are equal else throw an error, and

Return dynamic variable definitions as Vector with elements of form :dv => [:arg1, :arg2]

Cycles are uniquely characterized by sets of edges, not sets of nodes We construct a simple graph, then for each edge, we check if there exist multiple edges with the same start and end node We then product all of them, to get every cycle.

This could be made more efficient, but it should be fine for now.

return the auxiliary variable's index that related to the flow with index of f

return the flows name with index of f

return flow names

funcDynam(p::AbstractStockAndFlow,v)

return the functions of variables give index v

funcDynam(sf::AbstractStockAndFlowF,v)

return the functions of variables give index v

generate the function substituting sum variables in with flow index fn

return the functions (not substitutes the function of sum variables yet) of flow index f

return the LVector of pairs: fname => function (with function of sum variables substitue in)

return the LVector of pairs: fname => function (raw: not substitutes the function of sum variables yet)

generate the function of a sum auxiliary variable (index sv) with the sum of all stocks links to it

return the LVector of pairs: svname => function

get flow variable of flow

get ordered list of indices of dynamic variable for each flow

return inflows of stock index s

return all inflows

return stocks of flow index f flow in

return argument position of source constant parameter of an auxiliary variable

return the pair of names of (stock, sum-auxiliary-variable) for all linkages between them

return argument position of source sum dynamical variable of an auxiliary variable

return argument position of source auxiliary variable of an auxiliary variable

return argument position of source stock variable of an auxiliary variable

create expresision of an auxiliary variable v

Generates the expression of an auxiliary variable, only going one layer deep If other dynamic variables make up its definition, they will not be substituted.

return count of edges of CLD

flow count

inflow count

link dynamic variable parameter count

link stock sum count

link sum variable dynamic variable count

link stock dynamic variable count

link dynamic variable dynamic variable count

return count of nodes of CLD

return node's name with index n

return node names of CLD

outflow count

parameter count

stock count

sum variable count

dynamic variable count

return outflows of stock index s

return all outflows

return stocks that flow index f flow out from

return the auxiliary variables name with index of v

return parameter names

Return a new stock flow with flattened names, operators and positions from the old

return edge's name with target number t

set flow names to vector of symbols

set parameter names to vector of symbols

set stock names to vector of symbols

set sum variable names to vector of symbols

set dynamic variable names to vector of symbols

return the stocks name with index of s

return stock names

return stocks that sum variable index sv link to

return stocks that auxiliary variable index v link to

return the sum auxiliary variables name with index of sv

return sum variable names

return sum auxiliary variables that stock s links to

return sum auxiliary variables all stocks link (frequency)

return sum variables that auxiliary variable index v link to

return edge's name with edge number e

return the auxiliary variables name with index of v

return variable names

return operator of an auxiliary variable

return auxiliary variable's source constant parameters

return constant parameters's link auxiliary variables

return auxiliary variable's target auxiliary variables it links to

return auxiliary variables that stock s links to

return auxiliary variables all stocks link (frequency)

return auxiliary variables that sum auxiliary variable sv links to

return auxiliary variables all sum auxiliary variables link (frequency)

return auxiliary variable's source auxiliary variables that it links to

Alternative syntax for use in the definition of stock and flow models.

Examples

# An S-I-R model of infection
SIR = @stock_and_flow begin
    :stocks
    S
    I
    R

    :parameters
    c
    beta
    tRec

    :dynamic_variables
    v_prevalence = I / N
    v_meanInfectiousContactsPerS = c * v_prevalence
    v_perSIncidenceRate = beta * v_meanInfectiousContactsPerS
    v_newInfections = S * v_perSIncidenceRate
    v_newRecovery = I / tRec

    :flows
    S => inf(v_newInfections) => I
    I => rec(v_newRecovery) => R

    :sums
    N = [S, I, R]
end

# Generates:
# SIR = StockAndFlowF(
#     # stocks
#     (:S => (:F_NONE, :inf, :N), :I => (:inf, :rec, :N), :R => (:rec, :F_NONE, :N)),
#     # parameters
#     (:c, :beta, :tRec),
#     # dynamical variables
#     (   :v_prevalence => ((:I, :N) => :/),
#         :v_meanInfectiousContactsPerS => ((:c, :v_prevalence) => :*),
#         :v_perSIncidenceRate => ((:beta, :v_meanInfectiousContactsPerS) => :*),
#         :v_newInfections => ((:S, :v_perSIncidenceRate) => :*),
#         :v_newRecovery => ((:I, :tRec) => :/),
#     ),
#     # flows
#     (:inf => :v_newInfections, :rec => :v_newRecovery),
#     # sum dynamical variables
#     (:N),
# )

# The same model as before, but with the dynamic variables inferred
SIR_2 = @stock_and_flow begin
    :stocks
    S
    I
    R

    :parameters
    c
    beta
    tRec

    # We can leave out dynamic variables and let them be inferred from flows entirely!

    :flows
    S => inf(S * beta * (c * (I / N))) => I
    I => rec(I / tRec) => R

    :sums
    N = [S, I, R]
end

# Another possible S-I-R model definition
SIR_3 = @stock_and_flow begin
    :stocks
    S
    I
    R

    :parameters
    c
    beta
    tRec
    omega
    alpha

    :dynamic_variables
    v_prevalence = I / totalPopulation
    v_forceOfInfection = c * v_prevalence * beta

    :flows
    S => inf(S * v_forceOfInfection) => I
    ☁ => births(totalPopulation * alpha) => S
    S => deathsS(S * omega) => ☁
    I => rec(I / tRec) => R
    I => deathsI(I * omega) => ☁
    R => deathsR(R * omega) => ☁


    :sums
    totalPopulation = [S, I, R]
end

infer_links(sfsrc :: StockAndFlowF, sftgt :: StockAndFlowF, NecMaps :: Dict{Symbol, Vector{Int64}})

Infer LS, I, O, LV, LSV, LVV, LPV mappings for an ACSetTransformation. Returns dictionary of Symbols to lists of indices, corresponding to an ACSetTransformation argument. If there exist no such mappings (eg, no LVV), that pairing will not be included in the returned dictionary.

If A <- C -> B, and we have A -> A' and B -> B' and a unique C' such that A' <- C' -> B', we can assume C -> C'.

:S => [2,4,1,3], :F => [1,2,4,3], ...

NecMaps must contain keys S, F, SV, P, V, each pointing to a (possibly empty) array of indices

feet(block :: Expr)

Create Vector of feet using same notation for foot macro. Separated by newlines. First argument is stock, second is sum variable.

feetses = @feet begin
    A => B
    () => N
    C => ()
    D => E
    () => ()
    P => NI, R => NI, () => N
end

foot(block :: Expr)

Create a foot with S => N syntax, where S is stock, N is sum variable.

@foot P => Q
@foot S1 => ()
@foot () => N
@foot () => ()
@foot A => N, () => NI

stock_and_flow(block :: Expr)

Compiles stock and flow syntax of the line-based block form

  :stocks
    symbol_1
    symbol_2
    ...
    symbol_n

  :parameters
    param_1
    param_2
    ...
    param_n

  :dynamic_variables
    dyvar_1 = symbol_h * param_g ... - symbol_x / param_y
    ...
    dyvar_n = symbol_k * param_j - dyvar_a ... - symbol_p / param_q

  :flows
    symbol_r => flow_name_1(dyvar_k) => symbol_q
    symbol_z => flow_name_2(dyvar_g * param_v) => symbol_p
    ☁       => flow_name_3(symbol_c + dyvar_b) => symbol_r
    symbol_j => flow_name_4(param_l + symbol_m) => CLOUD
    ...
    symbol_y => flow_name_n(dyvar_f) => ☁

into a StockAndFlowF data type for use with the StockFlow.jl modelling system.

Return a new SEIR model

Return a new SIR model

Return a new SIS model

Return a new SVI model