Merge pull request #14 from SebKrantz/parameterized_graph

Parameterized graph

Author: SebKrantz

README.md

@@ -42,15 +42,15 @@ import MathOptInterface as MOI
 import MathOptSymbolicAD
 
 param[:model_attr] = Dict(:backend => (MOI.AutomaticDifferentiationBackend(), 
-                                        MathOptSymbolicAD.DefaultBackend())) 
+                                       MathOptSymbolicAD.DefaultBackend())) 
                                 # Or:  MathOptSymbolicAD.ThreadedBackend()
 ```
 
 * It is recommended to use Coin-HSL linear solvers for [Ipopt](https://github.com/jump-dev/Ipopt.jl) to speed up computations. In my opinion the simplest way to use them is to get a (free for academics) license and download the binaries [here](https://licences.stfc.ac.uk/product/coin-hsl), extract them somewhere, and then set the `hsllib` (place here the path to where you extracted `libhsl.dylib`, it may also be called `libcoinhsl.dylib`, in which case you may have to rename it to `libhsl.dylib`) and `linear_solver` options as follows:
 
 ```julia
 param[:optimizer_attr] = Dict(:hsllib => "/usr/local/lib/libhsl.dylib", # Adjust path
-                                :linear_solver => "ma57") # Use ma57, ma86 or ma97
+                              :linear_solver => "ma57") # Use ma57, ma86 or ma97
 ```
 
 The [Ipopt.jl README](https://github.com/jump-dev/Ipopt.jl?tab=readme-ov-file#linear-solvers) suggests to use the larger LibHSL package for which there exists a Julia module and proceed similarly. In addition, users may try an [optimized BLAS](https://github.com/jump-dev/Ipopt.jl?tab=readme-ov-file#blas-and-lapack) and see if it yields significant performance gains (and let me know if it does). 

docs/src/api.md

@@ -41,10 +41,3 @@ OptimalTransportNetworks.represent_edges
 OptimalTransportNetworks.create_auxdata
 OptimalTransportNetworks.get_model
 ```
-
-<!-- ```@autodocs
-Modules = [OptimalTransportNetworks]
-Public = false
-Private = true
-Order = [:function]
-``` -->

docs/src/index.md

@@ -37,15 +37,15 @@ import MathOptInterface as MOI
 import MathOptSymbolicAD
 
 param[:model_attr] = Dict(:backend => (MOI.AutomaticDifferentiationBackend(), 
-                                        MathOptSymbolicAD.DefaultBackend())) 
+                                       MathOptSymbolicAD.DefaultBackend())) 
                                 # Or:  MathOptSymbolicAD.ThreadedBackend()
 ```
 
 * It is recommended to use Coin-HSL linear solvers for [Ipopt](https://github.com/jump-dev/Ipopt.jl) to speed up computations. In my opinion the simplest way to use them is to get a (free for academics) license and download the binaries [here](https://licences.stfc.ac.uk/product/coin-hsl), extract them somewhere, and then set the `hsllib` (place here the path to where you extracted `libhsl.dylib`, it may also be called `libcoinhsl.dylib`, in which case you may have to rename it to `libhsl.dylib`) and `linear_solver` options as follows:
 
 ```julia
 param[:optimizer_attr] = Dict(:hsllib => "/usr/local/lib/libhsl.dylib", # Adjust path
-                                :linear_solver => "ma57") # Use ma57, ma86 or ma97
+                              :linear_solver => "ma57") # Use ma57, ma86 or ma97
 ```
 
 The [Ipopt.jl README](https://github.com/jump-dev/Ipopt.jl?tab=readme-ov-file#linear-solvers) suggests to use the larger LibHSL package for which there exists a Julia module and proceed similarly. In addition, users may try an [optimized BLAS](https://github.com/jump-dev/Ipopt.jl?tab=readme-ov-file#blas-and-lapack) and see if it yields significant performance gains (and let me know if it does). 

examples/paper_example04.jl

@@ -3,7 +3,7 @@ using Random
 using Plots
 
 # Initialize parameters
-param = init_parameters(K = 100, rho = 0, labor_mobility = false)
+param = init_parameters(K = 100, sigma = 2, rho = 0, labor_mobility = false)
 width, height = 13, 13
 
 # Create graph
@@ -17,7 +17,7 @@ Ni = find_node(g0, ceil(width/2), ceil(height/2)) # center
 g0[:Zjn][Ni] = 1 # more productive node
 g0[:Lj][Ni] = 1 # more productive node
 
-Random.seed!(10) # use 5, 8, 10 or 11
+Random.seed!(11) # use 5, 8, 10 or 11
 nb_cities = 20 # draw a number of random cities in space
 for i in 1:nb_cities-1
     newdraw = false
@@ -113,11 +113,13 @@ plots = Vector{Any}(undef, length(simulation))
 i = 0
 for s in simulation
     i += 1
+    sizes = 2 .* results[Symbol(s)][:cj] .* (g0[:Lj] .> 1e-6) / maximum(results[Symbol(s)][:cj])
+    shades = results[Symbol(s)][:cj] .* (g0[:Lj] .> 1e-6) / maximum(results[Symbol(s)][:cj])
     plots[i] = plot_graph(g0, results[Symbol(s)][:Ijk], 
                           geography = geographies[Symbol(s)], obstacles = obstacles[i] == "on",
                           mesh = true, mesh_transparency = 0.2,
-                          node_sizes = results[Symbol(s)][:cj], 
-                          node_shades = g0[:Zjn], node_color = :seismic,
+                          node_sizes = sizes, node_shades = shades, 
+                          node_color = :seismic,
                           edge_min_thickness = 1, edge_max_thickness = 4)
     title!(plots[i], "Geography $(s)")
 end

src/OptimalTransportNetworks.jl

@@ -22,7 +22,8 @@ Fajgelbaum, P. D., & Schaal, E. (2020). Optimal transport networks in spatial eq
 
 The library is based on the JuMP modeling framework for mathematical optimization in Julia, and roughly follows the 
 MATLAB OptimalTransportNetworkToolbox (v1.0.4b) provided by the authors. Compared to MATLAB, the Julia library presents
-a simplified interface and only exports key functions, while retaining full flexibility. 
+a simplified interface. Notably, the `graph` object contains both the graph structure and all data parameterizing 
+the network, whereas the `param` object only contains (non-spatial) model parameters.
 
 # Exported Functions