Reformat source code; set up lint GH Action

.github/workflows/lint.yml

@@ -0,0 +1,27 @@
+name: Lint
+on:
+  push:
+  pull_request:
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: '1'
+      - uses: actions/checkout@v1
+      - name: Format check
+        shell: julia --color=yes {0}
+        run: |
+          using Pkg
+          Pkg.add(PackageSpec(name="JuliaFormatter", version="0.14.4"))
+          using JuliaFormatter
+          format("src", verbose=true)
+          format("test", verbose=true)
+          out = String(read(Cmd(`git diff`)))
+          if isempty(out)
+              exit(0)
+          end
+          @error "Some files have not been formatted !!!"
+          write(stdout, out)
+          exit(1)

Makefile

@@ -17,6 +17,9 @@ clean:
 docs:
 	mkdocs build -d ../docs/$(VERSION)/
 
+format:
+	julia -e 'using JuliaFormatter; format(["src", "test"], verbose=true);'
+
 test: build/test.log
 
 test-watch:

src/graph.jl

@@ -5,8 +5,7 @@
 using Geodesy
 
 
-abstract type Node
-end
+abstract type Node end
 
 
 mutable struct Arc
@@ -48,10 +47,9 @@ function build_graph(instance::Instance)::Graph
     plant_shipping_nodes = ShippingNode[]
     collection_shipping_nodes = ShippingNode[]
 
-    process_nodes_by_input_product = Dict(product => ProcessNode[]
-                                          for product in instance.products)
-    shipping_nodes_by_plant = Dict(plant => []
-                                   for plant in instance.plants)
+    process_nodes_by_input_product =
+        Dict(product => ProcessNode[] for product in instance.products)
+    shipping_nodes_by_plant = Dict(plant => [] for plant in instance.plants)
 
     # Build collection center shipping nodes
     for center in instance.collection_centers
@@ -78,10 +76,12 @@ function build_graph(instance::Instance)::Graph
     # Build arcs from collection centers to plants, and from one plant to another
     for source in [collection_shipping_nodes; plant_shipping_nodes]
         for dest in process_nodes_by_input_product[source.product]
-            distance = calculate_distance(source.location.latitude,
+            distance = calculate_distance(
+                source.location.latitude,
                 source.location.longitude,
                 dest.location.latitude,
-                                          dest.location.longitude)
+                dest.location.longitude,
+            )
             values = Dict("distance" => distance)
             arc = Arc(source, dest, values)
             push!(source.outgoing_arcs, arc)
@@ -103,10 +103,7 @@ function build_graph(instance::Instance)::Graph
         end
     end
 
-    return Graph(process_nodes, 
-                 plant_shipping_nodes,
-                 collection_shipping_nodes,
-                 arcs)
+    return Graph(process_nodes, plant_shipping_nodes, collection_shipping_nodes, arcs)
 end
 
 

src/instance.jl

@@ -125,12 +125,14 @@ function parse(json)::Instance
         # Create collection centers
         if "initial amounts" in keys(product_dict)
             for (center_name, center_dict) in product_dict["initial amounts"]
-                center = CollectionCenter(length(collection_centers) + 1,
+                center = CollectionCenter(
+                    length(collection_centers) + 1,
                     center_name,
                     center_dict["latitude (deg)"],
                     center_dict["longitude (deg)"],
                     product,
-                                          center_dict["amount (tonne)"])
+                    center_dict["amount (tonne)"],
+                )
                 push!(collection_centers, center)
             end
         end
@@ -143,9 +145,10 @@ function parse(json)::Instance
 
         # Plant outputs
         if "outputs (tonne/tonne)" in keys(plant_dict)
-            output = Dict(prod_name_to_product[key] => value
-                          for (key, value) in plant_dict["outputs (tonne/tonne)"]
-                          if value > 0)
+            output = Dict(
+                prod_name_to_product[key] => value for
+                (key, value) in plant_dict["outputs (tonne/tonne)"] if value > 0
+            )
         end
 
         energy = zeros(T)
@@ -161,27 +164,33 @@ function parse(json)::Instance
 
         for (location_name, location_dict) in plant_dict["locations"]
             sizes = PlantSize[]
-            disposal_limit = Dict(p => [0.0 for t in 1:T] for p in keys(output))
-            disposal_cost = Dict(p => [0.0 for t in 1:T] for p in keys(output))
+            disposal_limit = Dict(p => [0.0 for t = 1:T] for p in keys(output))
+            disposal_cost = Dict(p => [0.0 for t = 1:T] for p in keys(output))
 
             # Disposal
             if "disposal" in keys(location_dict)
                 for (product_name, disposal_dict) in location_dict["disposal"]
-                    limit = [1e8 for t in 1:T]
+                    limit = [1e8 for t = 1:T]
                     if "limit (tonne)" in keys(disposal_dict)
                         limit = disposal_dict["limit (tonne)"]
                     end
                     disposal_limit[prod_name_to_product[product_name]] = limit
-                    disposal_cost[prod_name_to_product[product_name]] = disposal_dict["cost (\$/tonne)"]
+                    disposal_cost[prod_name_to_product[product_name]] =
+                        disposal_dict["cost (\$/tonne)"]
                 end
             end
 
             # Capacities
             for (capacity_name, capacity_dict) in location_dict["capacities (tonne)"]
-                push!(sizes, PlantSize(Base.parse(Float64, capacity_name),
+                push!(
+                    sizes,
+                    PlantSize(
+                        Base.parse(Float64, capacity_name),
                         capacity_dict["variable operating cost (\$/tonne)"],
                         capacity_dict["fixed operating cost (\$)"],
-                                       capacity_dict["opening cost (\$)"]))
+                        capacity_dict["opening cost (\$)"],
+                    ),
+                )
             end
             length(sizes) > 1 || push!(sizes, sizes[1])
             sort!(sizes, by = x -> x.capacity)
@@ -203,7 +212,8 @@ function parse(json)::Instance
                 throw("Variable operating costs must be the same for all capacities")
             end
 
-            plant = Plant(length(plants) + 1,
+            plant = Plant(
+                length(plants) + 1,
                 plant_name,
                 location_name,
                 input,
@@ -216,7 +226,8 @@ function parse(json)::Instance
                 energy,
                 emissions,
                 storage_limit,
-                          storage_cost)
+                storage_cost,
+            )
 
             push!(plants, plant)
         end

src/model.jl

@@ -27,39 +27,50 @@ end
 function create_vars!(model::ManufacturingModel)
     mip, vars, graph, T = model.mip, model.vars, model.graph, model.instance.time
 
-    vars.flow = Dict((a, t) => @variable(mip, lower_bound=0)
-                    for a in graph.arcs, t in 1:T)
+    vars.flow = Dict((a, t) => @variable(mip, lower_bound = 0) for a in graph.arcs, t = 1:T)
 
-    vars.dispose = Dict((n, t) => @variable(mip,
+    vars.dispose = Dict(
+        (n, t) => @variable(
+            mip,
             lower_bound = 0,
-                                            upper_bound=n.location.disposal_limit[n.product][t])
-                        for n in values(graph.plant_shipping_nodes), t in 1:T)
+            upper_bound = n.location.disposal_limit[n.product][t]
+        ) for n in values(graph.plant_shipping_nodes), t = 1:T
+    )
 
-    vars.store = Dict((n, t) => @variable(mip,
-                                            lower_bound=0,
-                                            upper_bound=n.location.storage_limit)
-                        for n in values(graph.process_nodes), t in 1:T)
+    vars.store = Dict(
+        (n, t) =>
+            @variable(mip, lower_bound = 0, upper_bound = n.location.storage_limit) for
+        n in values(graph.process_nodes), t = 1:T
+    )
 
-    vars.process = Dict((n, t) => @variable(mip,
-                                            lower_bound = 0)
-                        for n in values(graph.process_nodes), t in 1:T)
+    vars.process = Dict(
+        (n, t) => @variable(mip, lower_bound = 0) for n in values(graph.process_nodes),
+        t = 1:T
+    )
 
-    vars.open_plant = Dict((n, t) => @variable(mip, binary=true)
-                           for n in values(graph.process_nodes), t in 1:T)
+    vars.open_plant = Dict(
+        (n, t) => @variable(mip, binary = true) for n in values(graph.process_nodes),
+        t = 1:T
+    )
 
-    vars.is_open = Dict((n, t) => @variable(mip, binary=true)
-                        for n in values(graph.process_nodes), t in 1:T)
+    vars.is_open = Dict(
+        (n, t) => @variable(mip, binary = true) for n in values(graph.process_nodes),
+        t = 1:T
+    )
 
-    vars.capacity = Dict((n, t) => @variable(mip,
-                                             lower_bound = 0,
-                                             upper_bound = n.location.sizes[2].capacity)
-                         for n in values(graph.process_nodes), t in 1:T)
+    vars.capacity = Dict(
+        (n, t) =>
+            @variable(mip, lower_bound = 0, upper_bound = n.location.sizes[2].capacity)
+        for n in values(graph.process_nodes), t = 1:T
+    )
 
-    vars.expansion = Dict((n, t) => @variable(mip,
+    vars.expansion = Dict(
+        (n, t) => @variable(
+            mip,
             lower_bound = 0,
-                                              upper_bound = n.location.sizes[2].capacity - 
-                                                            n.location.sizes[1].capacity)
-                         for n in values(graph.process_nodes), t in 1:T)
+            upper_bound = n.location.sizes[2].capacity - n.location.sizes[1].capacity
+        ) for n in values(graph.process_nodes), t = 1:T
+    )
 end
 
 
@@ -86,7 +97,7 @@ function create_objective_function!(model::ManufacturingModel)
     obj = AffExpr(0.0)
 
     # Process node costs
-    for n in values(graph.process_nodes), t in 1:T
+    for n in values(graph.process_nodes), t = 1:T
 
         # Transportation and variable operating costs
         for a in n.incoming_arcs
@@ -95,49 +106,45 @@ function create_objective_function!(model::ManufacturingModel)
         end
 
         # Opening costs
-        add_to_expression!(obj,
-                           n.location.sizes[1].opening_cost[t],
-                           vars.open_plant[n, t])
+        add_to_expression!(obj, n.location.sizes[1].opening_cost[t], vars.open_plant[n, t])
 
         # Fixed operating costs (base)
-        add_to_expression!(obj,
+        add_to_expression!(
+            obj,
             n.location.sizes[1].fixed_operating_cost[t],
-                           vars.is_open[n, t])
+            vars.is_open[n, t],
+        )
 
         # Fixed operating costs (expansion)
-        add_to_expression!(obj,
-                           slope_fix_oper_cost(n.location, t),
-                           vars.expansion[n, t])
+        add_to_expression!(obj, slope_fix_oper_cost(n.location, t), vars.expansion[n, t])
 
         # Processing costs
-        add_to_expression!(obj,
+        add_to_expression!(
+            obj,
             n.location.sizes[1].variable_operating_cost[t],
-                           vars.process[n, t])
+            vars.process[n, t],
+        )
 
         # Storage costs
-        add_to_expression!(obj,
-                           n.location.storage_cost[t],
-                           vars.store[n, t])
+        add_to_expression!(obj, n.location.storage_cost[t], vars.store[n, t])
 
         # Expansion costs
         if t < T
-            add_to_expression!(obj,
+            add_to_expression!(
+                obj,
                 slope_open(n.location, t) - slope_open(n.location, t + 1),
-                               vars.expansion[n, t])
+                vars.expansion[n, t],
+            )
         else
-            add_to_expression!(obj,
-                               slope_open(n.location, t),
-                               vars.expansion[n, t])
+            add_to_expression!(obj, slope_open(n.location, t), vars.expansion[n, t])
         end
     end
 
     # Shipping node costs
-    for n in values(graph.plant_shipping_nodes), t in 1:T
+    for n in values(graph.plant_shipping_nodes), t = 1:T
 
         # Disposal costs
-        add_to_expression!(obj,
-                           n.location.disposal_cost[n.product][t],
-                           vars.dispose[n, t])
+        add_to_expression!(obj, n.location.disposal_cost[n.product][t], vars.dispose[n, t])
     end
 
     @objective(mip, Min, obj)
@@ -150,19 +157,22 @@ function create_shipping_node_constraints!(model::ManufacturingModel)
 
     eqs.balance = OrderedDict()
 
-    for t in 1:T
+    for t = 1:T
         # Collection centers
         for n in graph.collection_shipping_nodes
-            eqs.balance[n, t] = @constraint(mip,
-                                            sum(vars.flow[a, t] for a in n.outgoing_arcs)
-                                              == n.location.amount[t])
+            eqs.balance[n, t] = @constraint(
+                mip,
+                sum(vars.flow[a, t] for a in n.outgoing_arcs) == n.location.amount[t]
+            )
         end
 
         # Plants
         for n in graph.plant_shipping_nodes
-            @constraint(mip,
+            @constraint(
+                mip,
                 sum(vars.flow[a, t] for a in n.incoming_arcs) ==
-                sum(vars.flow[a, t] for a in n.outgoing_arcs) + vars.dispose[n, t])
+                sum(vars.flow[a, t] for a in n.outgoing_arcs) + vars.dispose[n, t]
+            )
         end
     end
 
@@ -172,7 +182,7 @@ end
 function create_process_node_constraints!(model::ManufacturingModel)
     mip, vars, graph, T = model.mip, model.vars, model.graph, model.instance.time
 
-    for t in 1:T, n in graph.process_nodes
+    for t = 1:T, n in graph.process_nodes
         input_sum = AffExpr(0.0)
         for a in n.incoming_arcs
             add_to_expression!(input_sum, 1.0, vars.flow[a, t])
@@ -184,13 +194,22 @@ function create_process_node_constraints!(model::ManufacturingModel)
         end
 
         # If plant is closed, capacity is zero
-        @constraint(mip, vars.capacity[n, t] <= n.location.sizes[2].capacity * vars.is_open[n, t])
+        @constraint(
+            mip,
+            vars.capacity[n, t] <= n.location.sizes[2].capacity * vars.is_open[n, t]
+        )
 
         # If plant is open, capacity is greater than base
-        @constraint(mip, vars.capacity[n, t] >= n.location.sizes[1].capacity * vars.is_open[n, t])
+        @constraint(
+            mip,
+            vars.capacity[n, t] >= n.location.sizes[1].capacity * vars.is_open[n, t]
+        )
 
         # Capacity is linked to expansion
-        @constraint(mip, vars.capacity[n, t] <= n.location.sizes[1].capacity + vars.expansion[n, t])
+        @constraint(
+            mip,
+            vars.capacity[n, t] <= n.location.sizes[1].capacity + vars.expansion[n, t]
+        )
 
         # Can only process up to capacity
         @constraint(mip, vars.process[n, t] <= vars.capacity[n, t])
@@ -209,14 +228,16 @@ function create_process_node_constraints!(model::ManufacturingModel)
         if t == T
             @constraint(mip, vars.store[n, t] == 0)
         end
-        @constraint(mip,
-                    input_sum + store_in == vars.store[n, t] + vars.process[n, t])
+        @constraint(mip, input_sum + store_in == vars.store[n, t] + vars.process[n, t])
 
 
         # Plant is currently open if it was already open in the previous time period or
         # if it was built just now
         if t > 1
-            @constraint(mip, vars.is_open[n, t] == vars.is_open[n, t-1] + vars.open_plant[n, t])
+            @constraint(
+                mip,
+                vars.is_open[n, t] == vars.is_open[n, t-1] + vars.open_plant[n, t]
+            )
         else
             @constraint(mip, vars.is_open[n, t] == vars.open_plant[n, t])
         end
@@ -231,7 +252,8 @@ end
 default_milp_optimizer = optimizer_with_attributes(Cbc.Optimizer, "logLevel" => 0)
 default_lp_optimizer = optimizer_with_attributes(Clp.Optimizer, "LogLevel" => 0)
 
-function solve(instance::Instance;
+function solve(
+    instance::Instance;
     optimizer = nothing,
     output = nothing,
     marginal_costs = true,
@@ -248,7 +270,10 @@ function solve(instance::Instance;
     @info @sprintf("    %12d time periods", instance.time)
     @info @sprintf("    %12d process nodes", length(graph.process_nodes))
     @info @sprintf("    %12d shipping nodes (plant)", length(graph.plant_shipping_nodes))
-    @info @sprintf("    %12d shipping nodes (collection)", length(graph.collection_shipping_nodes))
+    @info @sprintf(
+        "    %12d shipping nodes (collection)",
+        length(graph.collection_shipping_nodes)
+    )
     @info @sprintf("    %12d arcs", length(graph.arcs))
 
     @info "Building optimization model..."
@@ -286,19 +311,13 @@ function solve(instance::Instance;
     return solution
 end
 
-function solve(filename::AbstractString;
-               heuristic=false,
-               kwargs...,
-              )
+function solve(filename::AbstractString; heuristic = false, kwargs...)
     @info "Reading $filename..."
     instance = RELOG.parsefile(filename)
     if heuristic && instance.time > 1
         @info "Solving single-period version..."
         compressed = _compress(instance)
-        csol = solve(compressed;
-                     output=nothing,
-                     marginal_costs=false,
-                     kwargs...)
+        csol = solve(compressed; output = nothing, marginal_costs = false, kwargs...)
         @info "Filtering candidate locations..."
         selected_pairs = []
         for (plant_name, plant_dict) in csol["Plants"]
@@ -320,10 +339,9 @@ function solve(filename::AbstractString;
 end
 
 
-function get_solution(model::ManufacturingModel;
-                      marginal_costs=true,
-                     )
-    mip, vars, eqs, graph, instance = model.mip, model.vars, model.eqs, model.graph, model.instance
+function get_solution(model::ManufacturingModel; marginal_costs = true)
+    mip, vars, eqs, graph, instance =
+        model.mip, model.vars, model.eqs, model.graph, model.instance
     T = instance.time
 
     output = OrderedDict(
@@ -339,10 +357,8 @@ function get_solution(model::ManufacturingModel;
             "Storage (\$)" => zeros(T),
             "Total (\$)" => zeros(T),
         ),
-        "Energy" => OrderedDict(
-            "Plants (GJ)" => zeros(T),
-            "Transportation (GJ)" => zeros(T),
-        ),
+        "Energy" =>
+            OrderedDict("Plants (GJ)" => zeros(T), "Transportation (GJ)" => zeros(T)),
         "Emissions" => OrderedDict(
             "Plants (tonne)" => OrderedDict(),
             "Transportation (tonne)" => OrderedDict(),
@@ -362,8 +378,10 @@ function get_solution(model::ManufacturingModel;
     if marginal_costs
         for n in graph.collection_shipping_nodes
             location_dict = OrderedDict{Any,Any}(
-                "Marginal cost (\$/tonne)" => [round(abs(JuMP.shadow_price(eqs.balance[n, t])), digits=2)
-                                               for t in 1:T]
+                "Marginal cost (\$/tonne)" => [
+                    round(abs(JuMP.shadow_price(eqs.balance[n, t])), digits = 2) for
+                    t = 1:T
+                ],
             )
             if n.product.name ∉ keys(output["Products"])
                 output["Products"][n.product.name] = OrderedDict()
@@ -378,54 +396,57 @@ function get_solution(model::ManufacturingModel;
         process_node = plant_to_process_node[plant]
         plant_dict = OrderedDict{Any,Any}(
             "Input" => OrderedDict(),
-            "Output" => OrderedDict(
-                "Send" => OrderedDict(),
-                "Dispose" => OrderedDict(),
-            ),
+            "Output" =>
+                OrderedDict("Send" => OrderedDict(), "Dispose" => OrderedDict()),
             "Input product" => plant.input.name,
-            "Total input (tonne)" => [0.0 for t in 1:T],
+            "Total input (tonne)" => [0.0 for t = 1:T],
             "Total output" => OrderedDict(),
             "Latitude (deg)" => plant.latitude,
             "Longitude (deg)" => plant.longitude,
-            "Capacity (tonne)" => [JuMP.value(vars.capacity[process_node, t])
-                                   for t in 1:T],
-            "Opening cost (\$)" => [JuMP.value(vars.open_plant[process_node, t]) *
-                                    plant.sizes[1].opening_cost[t]
-                                    for t in 1:T],
-            "Fixed operating cost (\$)" => [JuMP.value(vars.is_open[process_node, t]) *
+            "Capacity (tonne)" =>
+                [JuMP.value(vars.capacity[process_node, t]) for t = 1:T],
+            "Opening cost (\$)" => [
+                JuMP.value(vars.open_plant[process_node, t]) *
+                plant.sizes[1].opening_cost[t] for t = 1:T
+            ],
+            "Fixed operating cost (\$)" => [
+                JuMP.value(vars.is_open[process_node, t]) *
                 plant.sizes[1].fixed_operating_cost[t] +
-                                            JuMP.value(vars.expansion[process_node, t]) *
-                                            slope_fix_oper_cost(plant, t)
-                                            for t in 1:T],
-            "Expansion cost (\$)" => [(if t == 1
+                JuMP.value(vars.expansion[process_node, t]) * slope_fix_oper_cost(plant, t) for t = 1:T
+            ],
+            "Expansion cost (\$)" => [
+                (
+                    if t == 1
                         slope_open(plant, t) * JuMP.value(vars.expansion[process_node, t])
                     else
                         slope_open(plant, t) * (
                             JuMP.value(vars.expansion[process_node, t]) -
                             JuMP.value(vars.expansion[process_node, t-1])
                         )
-                                       end)
-                                      for t in 1:T],
-            "Process (tonne)" => [JuMP.value(vars.process[process_node, t])
-                                  for t in 1:T],
-            "Variable operating cost (\$)" => [JuMP.value(vars.process[process_node, t]) *
-                                               plant.sizes[1].variable_operating_cost[t]
-                                               for t in 1:T],
-            "Storage (tonne)" => [JuMP.value(vars.store[process_node, t])
-                                for t in 1:T],
-            "Storage cost (\$)" => [JuMP.value(vars.store[process_node, t]) *
-                                    plant.storage_cost[t]
-                                    for t in 1:T],
+                    end
+                ) for t = 1:T
+            ],
+            "Process (tonne)" =>
+                [JuMP.value(vars.process[process_node, t]) for t = 1:T],
+            "Variable operating cost (\$)" => [
+                JuMP.value(vars.process[process_node, t]) *
+                plant.sizes[1].variable_operating_cost[t] for t = 1:T
+            ],
+            "Storage (tonne)" => [JuMP.value(vars.store[process_node, t]) for t = 1:T],
+            "Storage cost (\$)" => [
+                JuMP.value(vars.store[process_node, t]) * plant.storage_cost[t] for t = 1:T
+            ],
         )
         output["Costs"]["Fixed operating (\$)"] += plant_dict["Fixed operating cost (\$)"]
-        output["Costs"]["Variable operating (\$)"] += plant_dict["Variable operating cost (\$)"]
+        output["Costs"]["Variable operating (\$)"] +=
+            plant_dict["Variable operating cost (\$)"]
         output["Costs"]["Opening (\$)"] += plant_dict["Opening cost (\$)"]
         output["Costs"]["Expansion (\$)"] += plant_dict["Expansion cost (\$)"]
         output["Costs"]["Storage (\$)"] += plant_dict["Storage cost (\$)"]
 
         # Inputs
         for a in process_node.incoming_arcs
-            vals = [JuMP.value(vars.flow[a, t]) for t in 1:T]
+            vals = [JuMP.value(vars.flow[a, t]) for t = 1:T]
             if sum(vals) <= 1e-3
                 continue
             end
@@ -435,19 +456,16 @@ function get_solution(model::ManufacturingModel;
                 "Distance (km)" => a.values["distance"],
                 "Latitude (deg)" => a.source.location.latitude,
                 "Longitude (deg)" => a.source.location.longitude,
-                "Transportation cost (\$)" => a.source.product.transportation_cost .*
-                                              vals .*
-                                              a.values["distance"],
-                "Transportation energy (J)" => vals .*
-                                               a.values["distance"] .*
-                                               a.source.product.transportation_energy,
+                "Transportation cost (\$)" =>
+                    a.source.product.transportation_cost .* vals .* a.values["distance"],
+                "Transportation energy (J)" =>
+                    vals .* a.values["distance"] .* a.source.product.transportation_energy,
                 "Emissions (tonne)" => OrderedDict(),
             )
             emissions_dict = output["Emissions"]["Transportation (tonne)"]
             for (em_name, em_values) in a.source.product.transportation_emissions
-                dict["Emissions (tonne)"][em_name] = em_values .*
-                                                     dict["Amount (tonne)"] .*
-                                                     a.values["distance"]
+                dict["Emissions (tonne)"][em_name] =
+                    em_values .* dict["Amount (tonne)"] .* a.values["distance"]
                 if em_name ∉ keys(emissions_dict)
                     emissions_dict[em_name] = zeros(T)
                 end
@@ -467,7 +485,8 @@ function get_solution(model::ManufacturingModel;
             plant_dict["Input"][plant_name][location_name] = dict
             plant_dict["Total input (tonne)"] += vals
             output["Costs"]["Transportation (\$)"] += dict["Transportation cost (\$)"]
-            output["Energy"]["Transportation (GJ)"] += dict["Transportation energy (J)"] / 1e9
+            output["Energy"]["Transportation (GJ)"] +=
+                dict["Transportation energy (J)"] / 1e9
         end
 
         plant_dict["Energy (GJ)"] = plant_dict["Total input (tonne)"] .* plant.energy
@@ -476,7 +495,8 @@ function get_solution(model::ManufacturingModel;
         plant_dict["Emissions (tonne)"] = OrderedDict()
         emissions_dict = output["Emissions"]["Plants (tonne)"]
         for (em_name, em_values) in plant.emissions
-            plant_dict["Emissions (tonne)"][em_name] = em_values .* plant_dict["Total input (tonne)"]
+            plant_dict["Emissions (tonne)"][em_name] =
+                em_values .* plant_dict["Total input (tonne)"]
             if em_name ∉ keys(emissions_dict)
                 emissions_dict[em_name] = zeros(T)
             end
@@ -489,21 +509,23 @@ function get_solution(model::ManufacturingModel;
             plant_dict["Total output"][product_name] = zeros(T)
             plant_dict["Output"]["Send"][product_name] = product_dict = OrderedDict()
 
-            disposal_amount = [JuMP.value(vars.dispose[shipping_node, t]) for t in 1:T]
+            disposal_amount = [JuMP.value(vars.dispose[shipping_node, t]) for t = 1:T]
             if sum(disposal_amount) > 1e-5
                 skip_plant = false
-                plant_dict["Output"]["Dispose"][product_name] = disposal_dict = OrderedDict()
-                disposal_dict["Amount (tonne)"] = [JuMP.value(model.vars.dispose[shipping_node, t])
-                                                   for t in 1:T]
-                disposal_dict["Cost (\$)"] = [disposal_dict["Amount (tonne)"][t] *
-                                              plant.disposal_cost[shipping_node.product][t]
-                                              for t in 1:T]
+                plant_dict["Output"]["Dispose"][product_name] =
+                    disposal_dict = OrderedDict()
+                disposal_dict["Amount (tonne)"] =
+                    [JuMP.value(model.vars.dispose[shipping_node, t]) for t = 1:T]
+                disposal_dict["Cost (\$)"] = [
+                    disposal_dict["Amount (tonne)"][t] *
+                    plant.disposal_cost[shipping_node.product][t] for t = 1:T
+                ]
                 plant_dict["Total output"][product_name] += disposal_amount
                 output["Costs"]["Disposal (\$)"] += disposal_dict["Cost (\$)"]
             end
 
             for a in shipping_node.outgoing_arcs
-                vals = [JuMP.value(vars.flow[a, t]) for t in 1:T]
+                vals = [JuMP.value(vars.flow[a, t]) for t = 1:T]
                 if sum(vals) <= 1e-3
                     continue
                 end
@@ -517,7 +539,8 @@ function get_solution(model::ManufacturingModel;
                 if a.dest.location.plant_name ∉ keys(product_dict)
                     product_dict[a.dest.location.plant_name] = OrderedDict()
                 end
-                product_dict[a.dest.location.plant_name][a.dest.location.location_name] = dict
+                product_dict[a.dest.location.plant_name][a.dest.location.location_name] =
+                    dict
                 plant_dict["Total output"][product_name] += vals
             end
         end

src/reports.jl

@@ -27,7 +27,7 @@ function plants_report(solution)::DataFrame
     T = length(solution["Energy"]["Plants (GJ)"])
     for (plant_name, plant_dict) in solution["Plants"]
         for (location_name, location_dict) in plant_dict
-            for year in 1:T
+            for year = 1:T
                 capacity = round(location_dict["Capacity (tonne)"][year], digits = 2)
                 received = round(location_dict["Total input (tonne)"][year], digits = 2)
                 processed = round(location_dict["Process (tonne)"][year], digits = 2)
@@ -37,13 +37,20 @@ function plants_report(solution)::DataFrame
                 latitude = round(location_dict["Latitude (deg)"], digits = 6)
                 longitude = round(location_dict["Longitude (deg)"], digits = 6)
                 opening_cost = round(location_dict["Opening cost (\$)"][year], digits = 2)
-                expansion_cost = round(location_dict["Expansion cost (\$)"][year], digits=2)
-                fixed_cost = round(location_dict["Fixed operating cost (\$)"][year], digits=2)
-                var_cost = round(location_dict["Variable operating cost (\$)"][year], digits=2)
+                expansion_cost =
+                    round(location_dict["Expansion cost (\$)"][year], digits = 2)
+                fixed_cost =
+                    round(location_dict["Fixed operating cost (\$)"][year], digits = 2)
+                var_cost =
+                    round(location_dict["Variable operating cost (\$)"][year], digits = 2)
                 storage_cost = round(location_dict["Storage cost (\$)"][year], digits = 2)
-                total_cost = round(opening_cost + expansion_cost + fixed_cost +
-                                   var_cost + storage_cost, digits=2)
-                push!(df, [
+                total_cost = round(
+                    opening_cost + expansion_cost + fixed_cost + var_cost + storage_cost,
+                    digits = 2,
+                )
+                push!(
+                    df,
+                    [
                         plant_name,
                         location_name,
                         year,
@@ -61,7 +68,8 @@ function plants_report(solution)::DataFrame
                         var_cost,
                         storage_cost,
                         total_cost,
-                ])
+                    ],
+                )
             end
         end
     end
@@ -104,8 +112,10 @@ function plant_outputs_report(solution)::DataFrame
                 disposal_amount = round.(disposal_amount, digits = 2)
                 disposal_cost = round.(disposal_cost, digits = 2)
 
-                for year in 1:T
-                    push!(df, [
+                for year = 1:T
+                    push!(
+                        df,
+                        [
                             plant_name,
                             location_name,
                             year,
@@ -114,7 +124,8 @@ function plant_outputs_report(solution)::DataFrame
                             sent[year],
                             disposal_amount[year],
                             disposal_cost[year],
-                    ])
+                        ],
+                    )
                 end
             end
         end
@@ -134,14 +145,17 @@ function plant_emissions_report(solution)::DataFrame
     for (plant_name, plant_dict) in solution["Plants"]
         for (location_name, location_dict) in plant_dict
             for (emission_name, emission_amount) in location_dict["Emissions (tonne)"]
-                for year in 1:T
-                    push!(df, [
+                for year = 1:T
+                    push!(
+                        df,
+                        [
                             plant_name,
                             location_name,
                             year,
                             emission_name,
                             round(emission_amount[year], digits = 2),
-                    ])
+                        ],
+                    )
                 end
             end
         end
@@ -173,8 +187,10 @@ function transportation_report(solution)::DataFrame
         for (dst_location_name, dst_location_dict) in dst_plant_dict
             for (src_plant_name, src_plant_dict) in dst_location_dict["Input"]
                 for (src_location_name, src_location_dict) in src_plant_dict
-                    for year in 1:T
-                        push!(df, [
+                    for year = 1:T
+                        push!(
+                            df,
+                            [
                                 src_plant_name,
                                 src_location_name,
                                 round(src_location_dict["Latitude (deg)"], digits = 6),
@@ -186,13 +202,26 @@ function transportation_report(solution)::DataFrame
                                 dst_location_dict["Input product"],
                                 year,
                                 round(src_location_dict["Distance (km)"], digits = 2),
-                            round(src_location_dict["Amount (tonne)"][year], digits=2),
-                            round(src_location_dict["Amount (tonne)"][year] *
+                                round(
+                                    src_location_dict["Amount (tonne)"][year],
+                                    digits = 2,
+                                ),
+                                round(
+                                    src_location_dict["Amount (tonne)"][year] *
                                     src_location_dict["Distance (km)"],
-                                  digits=2),
-                            round(src_location_dict["Transportation cost (\$)"][year], digits=2),
-                            round(src_location_dict["Transportation energy (J)"][year] / 1e9, digits=2),
-                        ])
+                                    digits = 2,
+                                ),
+                                round(
+                                    src_location_dict["Transportation cost (\$)"][year],
+                                    digits = 2,
+                                ),
+                                round(
+                                    src_location_dict["Transportation energy (J)"][year] /
+                                    1e9,
+                                    digits = 2,
+                                ),
+                            ],
+                        )
                     end
                 end
             end
@@ -225,9 +254,12 @@ function transportation_emissions_report(solution)::DataFrame
         for (dst_location_name, dst_location_dict) in dst_plant_dict
             for (src_plant_name, src_plant_dict) in dst_location_dict["Input"]
                 for (src_location_name, src_location_dict) in src_plant_dict
-                    for (emission_name, emission_amount) in src_location_dict["Emissions (tonne)"]
-                        for year in 1:T
-                            push!(df, [
+                    for (emission_name, emission_amount) in
+                        src_location_dict["Emissions (tonne)"]
+                        for year = 1:T
+                            push!(
+                                df,
+                                [
                                     src_plant_name,
                                     src_location_name,
                                     round(src_location_dict["Latitude (deg)"], digits = 6),
@@ -239,13 +271,19 @@ function transportation_emissions_report(solution)::DataFrame
                                     dst_location_dict["Input product"],
                                     year,
                                     round(src_location_dict["Distance (km)"], digits = 2),
-                                round(src_location_dict["Amount (tonne)"][year], digits=2),
-                                round(src_location_dict["Amount (tonne)"][year] *
+                                    round(
+                                        src_location_dict["Amount (tonne)"][year],
+                                        digits = 2,
+                                    ),
+                                    round(
+                                        src_location_dict["Amount (tonne)"][year] *
                                         src_location_dict["Distance (km)"],
-                                      digits=2),
+                                        digits = 2,
+                                    ),
                                     emission_name,
                                     round(emission_amount[year], digits = 2),
-                            ])
+                                ],
+                            )
                         end
                     end
                 end
@@ -262,8 +300,7 @@ function write(solution::AbstractDict, filename::AbstractString)
     end
 end
 
-write_plants_report(solution, filename) =
-    CSV.write(filename, plants_report(solution))
+write_plants_report(solution, filename) = CSV.write(filename, plants_report(solution))
 
 write_plant_outputs_report(solution, filename) =
     CSV.write(filename, plant_outputs_report(solution))

src/sysimage.jl

@@ -9,14 +9,7 @@ using JuMP
 using MathOptInterface
 using ProgressBars
 
-pkg = [:Cbc,
-       :Clp,
-       :Geodesy,
-       :JSON,
-       :JSONSchema,
-       :JuMP,
-       :MathOptInterface,
-       :ProgressBars]
+pkg = [:Cbc, :Clp, :Geodesy, :JSON, :JSONSchema, :JuMP, :MathOptInterface, :ProgressBars]
 
 @info "Building system image..."
 create_sysimage(pkg, sysimage_path = "build/sysimage.so")

test/graph_test.jl

@@ -8,8 +8,8 @@ using RELOG
         basedir = dirname(@__FILE__)
         instance = RELOG.parsefile("$basedir/../instances/s1.json")
         graph = RELOG.build_graph(instance)
-        process_node_by_location_name = Dict(n.location.location_name => n
-                                             for n in graph.process_nodes)
+        process_node_by_location_name =
+            Dict(n.location.location_name => n for n in graph.process_nodes)
 
         @test length(graph.plant_shipping_nodes) == 8
         @test length(graph.collection_shipping_nodes) == 10
@@ -39,4 +39,3 @@ using RELOG
         @test length(graph.arcs) == 38
     end
 end
-

test/instance_test.jl

@@ -124,4 +124,3 @@ using RELOG
         @test l1.disposal_cost[p3] ≈ [-10.0]
     end
 end
-

test/model_test.jl

@@ -11,11 +11,13 @@ using RELOG, Cbc, JuMP, Printf, JSON, MathOptInterface.FileFormats
         model = RELOG.build_model(instance, graph, Cbc.Optimizer)
         set_optimizer_attribute(model.mip, "logLevel", 0)
 
-        process_node_by_location_name = Dict(n.location.location_name => n
-                                             for n in graph.process_nodes)
+        process_node_by_location_name =
+            Dict(n.location.location_name => n for n in graph.process_nodes)
 
-        shipping_node_by_location_and_product_names = Dict((n.location.location_name, n.product.name) => n
-                                                           for n in graph.plant_shipping_nodes)
+        shipping_node_by_location_and_product_names = Dict(
+            (n.location.location_name, n.product.name) => n for
+            n in graph.plant_shipping_nodes
+        )
 
         @test length(model.vars.flow) == 76
         @test length(model.vars.dispose) == 16
@@ -44,8 +46,8 @@ using RELOG, Cbc, JuMP, Printf, JSON, MathOptInterface.FileFormats
     @testset "solve (exact)" begin
         solution_filename_a = tempname()
         solution_filename_b = tempname()
-        solution = RELOG.solve("$(pwd())/../instances/s1.json",
-                               output=solution_filename_a)
+        solution =
+            RELOG.solve("$(pwd())/../instances/s1.json", output = solution_filename_a)
 
         @test isfile(solution_filename_a)