Simulating a Logistical Recycling Process

(1)

Mekelweg 2 2628 CD Delft the Netherlands Phone +31 (0)15-2782889 Fax +31 (0)15-2781397 www.mtt.tudelft.nl

This report consists of 16 pages and 0 appendices. It may only be reproduced literally and as a whole. For commercial purposes only with written authorization of Delft University of Technology. Requests for consult are only taken into consideration under the condition that the applicant denies all legal rights on liabilities concerning the contents of the advice.

Specialization: Production Engineering and Logistics Report number: 2013.TEL.7750

Title: Simulating a Logistical Recycling

Process

Author: J.A. Verbeek

Title (in Dutch) Simuleren van een Logistiek Recycling Proces.

Assignment: Simulation-assignment

Confidential: no

Initiator (university): dr. ir. H.P.M. Veeke Initiator (company): n/a

Supervisor: dr. ir. H.P.M. Veeke

(2)

Mekelweg 2 2628 CD Delft the Netherlands Phone +31 (0)15-2782889 Fax +31 (0)15-2781397 www.mtt.tudelft.nl 1

Student: J.A. Verbeek Assignment type: Simulation

Supervisor (TUD): dr. ir. H.P.M. Veeke

(TU Delft) Creditpoints (EC): 15

Supervisor (Company) n/a Specialization: PEL

Report number: 2013.TEL.7750 Confidential: No

Subject: Simulating a Logistical Recycling Process.

This report describes the workings of a computer simulation program in Delphi. The program simulates a hypothesis written in the essay: “How to Fuel Recycling: An essay on why gas stations are the ideal

location to collect consumer electronics, plastics and other waste to increase recycling.”

The main idea of essay is to collect recyclables at fuel stations, which are otherwise brought by car to municipalities waste drop-off points. Consumers who own a car visit a fuel station at some time anyway, so this saves a ride to the waste drop-off point. This saves fuel and thus CO2 emissions, however, trucks must collect the waste from all the fuel stations periodically and bring it to the drop-off point. This costs fuel and CO2, and depending on the situation, the benefits may be nullified. This calls for a computer simulation that can simulate real-life situations.

The program simulates the whole chain from user, to fuel station, to drop-off point. It outputs the fuel and CO2 savings of the proposed situation (above) compared to the current situation where consumers bring their recyclables directly to a drop-off point.

Municipalities can use this software to calculate for their city what the savings are. Therefore, the program needs to be flexible, to be suited to any city. Therefore, it has Google Maps integration, which allows it to use location data for any place in the world. Most relevant numbers (such as waste per month) can be inputted freely. The data for Amstelveen, The Netherlands, is supplied.

The simulation analyzes the results and gives feedback on service levels, and suggests the use of

more/less trucks and/or fuel stations. The program is robust; it does not produce errors if the input data contains the wrong decimal separator (comma or point). If an error does occur, it gives feedback on how to prevent the error. This report describes the workings of the Maps integration, the 2-OPT shortest path algorithm and the analysis module.

The professor,

(3)

1

1 Preface

This report is written for the course ME2110-10. I opted to create a computer simulation program for this course. The simulation program is written, and this report accompanies the simulation program with necessary information. The report contains an introduction to the subject, an overview of the functions of the program, algorithms presented in Program Description Language (PDL), verification of the final code and finally the results and conclusion of the simulation.

2 Introduction

“Write an essay about an original plan to improve sustainability by optimizing logistics.“ With this assignment, the course Sustainability (ME1400) began. I took part in this course and wrote the essay:

“How to Fuel Recycling: An essay on why gas stations are the ideal location to collect consumer

electronics, plastics and other waste to increase recycling.” The main idea is to collect recyclables at fuel

stations, that are otherwise brought by car to municipalities waste drop-off points. Consumers who own a car have to visit a fuel station at some time anyways, so this saves a ride to the waste drop-off point. This saves fuel and thus CO2 emissions, however, trucks must collect the waste from all the fuel stations periodically and bring it to the drop-off point. This costs fuel and CO2, the question is, is it worth it? This program simulates the whole chain from user, to fuel station, to drop-off point. It outputs the fuel and CO2 savings of the proposed situation (above) compared to the current situation where consumers bring their recyclables directly to a drop-off point.

The idea is that municipalities can use this software to calculate for their city what the savings are. Therefore, the program needs to be flexible, and not just suited for one city. Instead, has Google Maps integration, which allows it to use location data for any place in the world. Most relevant numbers (such as waste per month) can be inputted freely, but the data for Amstelveen is already supplied. The simulation analyzes the results and gives feedback on service levels, and suggests the use of more/less trucks and/or fuel stations. The program is robust; it does not produce errors if the input data contains the wrong decimal separator (comma or point). If an error does occur, it gives feedback on how to prevent the error.

(5)

3

3 Overview of the main functions

3.1 Input

3.1.1 Addresses

The simulation program is very flexible. Instead of simulating a fixed situation, or only changing

parameters, the actual setting (location) it simulates can be changed to fit any situation. The user inputs the addresses of the fuel stations and drop off point. Any number of fuel stations is possible.

3.1.2 Shortest Path

When the addresses of the depot and fuel stations are entered, the program sends many requests to Google’s Maps service, which returns the distances between any origin-destination pair of addresses. These distances are put in a cost matrix. An offline mode is also available, this loads an offline cost-matrix from a textfile.

A shortest path algorithm in Delphi finds the shortest round-trip path. The 2-OPT algorithm is selected from the many existing heuristic algorithms, as it comes close to the absolute best solution, while being a lot faster. This algorithm did not yet exist in Pascal, so it was written for this program. This algorithm is also easy to transfer to other programs by its clean design.

After Delphi has calculated the shortest path, it sends this path (with the corresponding addresses) to Google again. The Google Maps applet will then show the shortest path in the browser. While it is not necessary, it is nice to have visual feedback on the simulation.

Technically this was most challenging, because of the need to include a web browser into the program. The web browser works with HTML, the Google Maps service works with JavaScript, and this HTML and JavaScript is coded and executed in Pascal. Additionally, the browser cannot directly send values back to Delphi, so reading out received cost/distance values requires workarounds. The details of this collection of algorithms are explained in Chapter 4 PDL.

3.2 Start Simulation

3.3 Create elements

When the user sees that the shortest path is known, he may start the simulation. The simulation creates Tomasqueues for each fuel station and the drop off point, as well as for the garbage truck. A plastics generator creates bags with plastic trash, these are the flowing element of the process. The arrival rate and size can be set. These elements enter one of the fuel stations at random, this simulates customers dropping off their plastics garbage at a fuel station.

User definable settings (and their default) are: Simulation runtime (1 month), Driving schedule (Weekly), fuel station capacity (5m3), truck capacity (15m3), mean truck speed (40 km/h), mean truck fuel

efficiency (6 km/L), plastic bag arrival rate (400 bags/week) and mean plastic bag size(50 L/bag). The last two (bag arrival rate and size) are based on the research in my paper ‘How to Fuel Recycling’ for the

(6)

4 course ME1400 Sustainability. The other values as fuel efficiency and truck capacity are taken from an average garbage truck.

3.4 Truck pick up route

The truck drives at fixed intervals and visits fuel stations according to the shortest path. At fuel stations it picks up the plastics from the fuel stations. When it returns to the Drop-Off Point, it empties its payload. In the event that the truck is already full before doing the last pickup, the truck returns to the Drop-Off Point to dump the load, and returns to the last visited fuel station. In the event that a fuel station’s inventory is already full, the new bags with plastics are refused. The number of times this happens is logged, when the simulations finishes this is used to calculated the Service Level of the fuel stations.

The amount of fuel used, and emission of the truck is logged, as these are the desired output values. The fuel usage is an adjustable parameter, the C02 is fixed at 1.8kg per L of fuel, (actually: 2.36kg CO2 per kg petrol and 2.61kg per kg diesel, under ideal conditions).

3.5 Analyzing results

The goal of the program is to make it possible for municipalities to calculate the fuel usage and emission savings of implementing plastic garbage collection at fuel stations. Therefore, in order to help users, the program places the results into context by indicating whether the results are significant. It also gives recommendations, for example: if the truck fills up too often, the program will recommend using a larger truck or letting a small truck driving more often. If fuel stations fill up so often that many consumers cannot drop-off their waste, it will suggest larger or more fuel stations that accept waste. The municipality may calculate the investment costs and effort to implement this situation, because the number of fuel stations that accept waste, and the number of truck pick-up cycles are known. A

municipality can balance investment costs to CO2 savings, and make further decisions based on this knowledge.

(7)

5

4 Program Description Language (PDL)

Elements in the to-be situations are: Plastics, Fuel stations, Trucks. This leads to the respective classes TPlastics, TFuelstations and TTrucks, along with generator class TGenerator to create plastics. Additional (non Tomas) functions are put in TCalculator, for many algorithms such as for calculating the Shortest Route, calculating costs and analyzing the results. The (non Tomas) TAnimator class is used to house all functions used in visually animating the simulation, but this is for clarity only. These functions could be put in TCalculator just as easy.

The main process is: Create Plastics -> Transport to Fuel Station Inventory -> Transport to Drop-off point.

4.1 Create Plastics and Transport to Fuel Station Inventory

Plastics (waste) are the flowing elements in this simulation, these elements have no process. Their size is assumed constant. They are generated with interarrivaltimes (depending on “Waste per Month”) and a random number (SourceNr) which is used to assign them to a fuel station. This simulates a consumer bringing waste to a fuel station. This results in the following three classes:

TFuelstation class(TomasElement) Inventory: TomasQueue Capacity: Double Constructor Create TPlastic class(TomasElement) SourceNr: Integer Constructor Create TGenerator class(TomasElement) InterArrivalTimes: TExponentialDistribution Procedure Process Constructor Create Procedure TGenerator.Process; Begin Repeat Infinitely

Sample Time from Exponential Distribution Hold Time

Create Plastics

If random Fuel Station Inventory is not full, Add to random Fuel Station Inventory

If random Fuel Station Inventory is full, Add 1 to FuelStationWasFull counter. (and do not Add to random Fuel Station Inventory)

Add CO2 emissions to AS-IS situation CO2 emission. If TNow > Runtime then

InterruptSimulation.

Analyze CO2 emissions and Service Levels of the Fuel Stations and give user feedback. [procedure AnalyzeResults]

End Repeat

(8)

6

4.2 Transport to Drop-off point.

The following class is that of the Truck which collects the plastics. It must have an inventory (‘Payload’) and a process to move along the different fuel stations to pick up and drop off its load.

TTruck class(TomasElement) Payload: TomasQueue; Procedure Process Constructor Create Procedure TTruck.Process; Begin

Get addresses from Input. Repeat Infinitely

Move the Truck to next address (according to TSP solution) [procedure TSP]

If the address is a Fuel Station then

Transfer contents from Fuel Station to Truck If during Transfer Truck is Full

Move Truck to Depot

Transfer contents from Truck to Depot

Move Truck back to last address and continue Transfer. If the address is the Depot then

Transfer contents from Truck to Depot

Hold Truck until the next Scheduled Run starts

Throughout the above: Update visual feedback as Truck Location and state, Inventory Levels, update the Time, etc. [all procedures of TAnimation class]

Hold Truck for (driving distance to next address / driving speed speed) [function CalculatePathCost]

End Repeat

In the function above some additions have been typed in Red. These are extra functions or procedures to make the desired process happen. The TSP algorithm is most interesting; it will be described in one of the following chapters.

(9)

7

4.3 Interaction with Google Maps

Most simulation packages are flexible in the way that the user can enter a custom cost-matrix. For this simulation I wanted something different: That the user can input any addresses he likes for the Fuel Stations and Drop-off Depot, and that Google Maps is used to gather a cost-matrix. This is quite a complicated procedure.

4.3.1 From Addresses to Distance Cost-matrix:

1. The user inputs addresses for the Fuel Stations and Drop off Depot.

2. When the user clicks the “Send Google CostMatrix Request” button, the following happens: 3. Delphi puts the addresses in an Origin-Destination matrix (so for 5 addresses, a 5x5 matrix is

created).

4. Delphi creates Origin-Destination pairs (so for 5 addresses, 25 pairs exist). 5. The Delphi Form creates a Webbrowser to interact with the internet.

6. The Webbrowser loads an html page, of which the HTML code is written in Delphi.

7. This HTML page also contains Javascript code to load a Google Maps Applet. The Applet size is put to 100% of browser size, so of the HTML page, the user can only see the Maps applet and nothing else.

8. Delphi sends the addresses-pairs in Javascript to the Webbrowser, which get executed by the Google Maps Applet. The Applet passes on the addresses to the Google Maps Server with the request for the Distance between these addresses.

This is actually the same procedure as going to http://maps.google.com and getting a route description, but now it is automated to do it 25 times in a row.

9. For every Origin-Destination pair it also returns the distance value to the Maps Applet. This is also written on HTML page in an area that the user cannot see. This is a work around, because the Google Maps Server cannot send data to Delphi directly itself, but it can edit the HTML page, so therefore it is ‘stored’ in the HTML page.

10. Delphi can read the source code of the HTML page in the webbrowser, which now contains the distance data put in by Google. It searches for distance data, extracts the distance data and then puts it in a costmatrix. This costmatrix is now complete for use in Delphi by the TSP solver algorithm.

4.3.2 Error Checking

This complicated procedure may have errors, because firstly, Google is bombarded with requests, and some will take longer than others to complete. Some results will come in a wrong order, or will not come at all. Secondly, a bad internet connection can cause random errors or delays as well. Therefore, error checking occurs on the costmatrix in two ways:

- Are all fields filled in? - Are all the diagonals zero?

If the answer is no to either question, then the user is instructed to press the “Send Google CostMatrix Request” button again. Usually it will be much quicker and without errors this time, because Google still has the previous results in cache.

(10)

8 If the answer is yes to both questions, then the TSP solution will start and give an answer on what the shortest round trip is. Another procedure (DrawTSPinMaps) then executes Javascript to show this final route in the Google Maps Applet, so the user can see the result of all this work.

The reader is invited to take a look at the following functions to see how the structure fits together:

{$REGION ' Long JavaScript - Double Click to Expand '} Const HTMLStr: AnsiString =…

This region with the HTMLString contains the HTML for the page in the webbrowser, so it has HTML and Javascript to load the Maps Applet. Furthermore, it contains all the Javascript coded functions that are called and executed from the procedures below.

procedure TSDIAppForm.ButtonSendGoogleCostMatrixRequest

This function is the first half on the Google Maps perspective. It sends the inputted Cities to JavaScript functions, which then: 1. Put markers on the map for each fuelstation (PutMarker)

2. Calculate the distances between every combination of source and destination. 3. Write the results that Google gives in hidden HTML DIV's result_distance.

procedure TCalculator.ImportCostMatrix

This Procedure imports the CostMatrix data from the HTML Inner Div into the Delphi StringGrid1. As commented in the code, it first places the Costs

from HTML Inner Div into MemoBox, then from MemoBox into StringGrid. Otherwise Delphi can't keep the Linebreaks intact, as used in the matrix.

(11)

9

4.4 The Travelling Salesman Problem (TSP) Algorithm

Another interesting piece of code is the Travelling Salesman Problem (TSP) algorithm. This code finds the shortest path in a network of nodes. This path must follow the condition that each node is visited once and only once, and that the route is round-trip. In this simulation, the TSP algorithm is used in the routing of the truck (chapter 4.2 Transport to Drop Off point).

4.4.1 Selecting the right algorithm

The main choice is between using a brute force algorithm, or a heuristic algorithm. A brute force algorithm checks all possible options to find the absolute minimal route length. However, it is also the slowest: with 8 nodes, a brute force algorithm will take more than a minute to solve on modern dual-core processor. Also, it is rather uninteresting scientifically. Therefore, a heuristic algorithm was chosen. A heuristic algorithm may not find the absolute shortest path, but will find a path close to the shortest path in a fraction of the time. According to literature1, the most accurate local iterative solving are:

Algorithm Accuracy

3-OPT 98%

2-OPT 95%

Christophides 91%

Where accuracy means “mean deviation from lowest cost”. The 3-OPT algorithm is not very well documented, however the 2-OPT algorithm, also known as the Sub-Tour Reversal algorithm, is documented in Introductions to Operations Research Ch.13 , Hillier. Therefore, this last algorithm is chosen for implementation.

4.4.2 Example

Algorithm Example with 4 nodes [A,B,C,D], the default route is: A-B-C-D-A. With cost: 60. In the following step, mutate the order of two nodes in the route.

Swap A-(B)-(C)-D-A to A-C-B-D-A, With cost: 55

A-(B)-C-(D)-A to A-D-C-B-A, With cost: 53 <--- SELECT LOWEST A-B-(C)-(D)-A to A-B-D-C-A, With cost: 70

Select the path with the lowest cost, A-D-C-B-A. With cost 53.

Now repeat the algorithm with this path: make mutations on this path and select the path with the lowest cost. Repeat until no mutations result in a lower cost. The path with this lowest cost is the shortest path, to be used in the simulation.

4.4.3 Algorithm PDL

begin

Create a local and global variable TSPCostMatrix

Construct an arbitrary roundtrip Route; for example CurrentPath = [0,1,2,3,0] Repeat

Calculate CurrentCost of CurrentPath [TCalculate.CalculatePathCost]

1

(12)

10 Fill MutationsArray with instances of the CurrentPath

Make different 2-OPT mutations in all the instances of the CurrentPath Calculate the cost of all mutations. [TCalculate.CalculatePathCost] Select the Route with the Lowest Cost and make that cost the NewLowestCost.

If CurrentCost is the NewLowestCost then 2-OPT is Optimal and exit loop. Else Make Path with Lowest Cost the CurrentPath

End Repeat End

Additionally, every time a shorter path is found, this path is written down in the “Console” in the top right of the simulation window. This way the user can see the algorithm working, which is specifically interesting for students and teachers.

4.5 The Vehicle Routing Problem (VRP) Algorithm

Aside from the TSP algorithm, also a complete Clarke-Wright Savings algorithm is implemented. The algorithm works, but is not used, because the idea of using two trucks for plastics pick-up was dropped. In real life this would not have any useful meaning, as one truck is more than sufficient. However, readers who are interested in a Savings algorithm in Delphi may take a look at procedure

TCalculator.VRP. This VRP is reasonably neatly coded, and may be used in other programs as well.

4.6 Starting the Simulation

Now that the main functions and procedures are complete, the simulation must be set up. The safest way is to do this when the user wants the simulation to start, and clicks the ‘start simulation’ button.

4.6.1 Start Simulation button PDL

begin

if UseGoogle then Calculator.ImportCostMatrix // Don't Import Google Costmatrix if offline file is used. if Import_succesful = false then exit

TSP VRP Animation := TAnimation.Create Animation.DrawTSPinMaps Animation.DrawInventories Animation.MoveTruck

Create a Fuel Station (TomasElement) per address Create a Truck (TomasElement)

Create a Generator (TomasElement) Start Truck TNow

Start Generator TNow StartSimulation

(13)

11

5 Verification

Validation and verification are important steps in the design of a simulation program. While validation is not possible for a non-existing situation, the simulation can be verified.

5.1 Verification of TSP algorithm

When the user presses “Load Costmatrix from offline file”, the following cost matrix gets loaded in the program:

Table 1 The offline cost matrix supplied with the simulation

FROM \ TO Depot Esso A Esso B Texaco A Shell A

0. Depot 0 1400 1400 1500 100

1. Esso A 100 0 1400 1100 1900

2. Esso B 1500 100 0 1400 1500

3. Texaco A 1100 1200 100 0 1400

4. Shell A 1300 1300 1100 100 0

It is quite trivial to see that the shortest round trip solution is:

Depot -> Shell A -> Texaco A -> Esso B -> Essa A -> Depot, with a cost of 500.

When the user clicks “Start Simulation”, the console reads the following output:

- Starting Travelling Salesman 2-OPT Algorithm, initial arbitrary route:->0->1->2->3->4->0 length: 6900 m - Current shortest route:->0->4->2->3->1->0 length: 3900 m. Algorithm resumes

- Current shortest route:->0->4->3->2->1->0 length: 500 m. Algorithm resumes

- TSP Optimum reached, route:->0->4->3->2->1->0 length: 500 m

The same route is found, thus the algorithm is verified.

5.2 Verfication of the Truck driving schedule

The default driving schedule is to start the pickup route weekly. A week has 604800 seconds, so the truck should hold in the depot until a multiple of 604800 is reached for TNow. (this simulation uses the counter of TNow as seconds). In the runs below, the offline cost matrix is used, the same as in the previous paragraph 5.1.

Upon starting the simulation, the Tomas Trace says: 0.00 Truck 1 holds until 604800.00 This is correct.

At 604800 the truck starts its route for the first time. Upon completing its first route, the Trace says: 604980.00 Truck 1 holds until 1209600.00

This is also correct.

(14)

12

5.3 Verification of the Truck driving times

During a simulation with the same cost matrix as in the previous paragraphs, the following occurs: The truck is finished with loading at Shell A and starts to drive to Texaco A;

Trace: 604809.00 Truck 1 holds until 604818.00

So to drive from Shell A to Texaco A takes 604818 – 604809 = 9 seconds in the simulation. According to the cost matrix, the distance is 100 meter, or 0.1 km.

The truck speed is 40 km/h, so it should take: 0.1 km / 40km/h = 0.0025 h = 9 seconds.

The simulation follows the theory, and is thus verified.

5.4 Verification of Bags of plastics arrival rate

The mean arrival rate is set as 400 bags/week. An exponential distribution is used for this. This equals to 0.0006614 bags per second or 1 bag every 1512 seconds.

The corresponding code is:

InterArrivalTimes:= TExponentialDistribution.Create (520623,(7*24*60*60)/StrToFloat(StringReplace(

SDIAppForm.EditMeanPiecesPerWeek.Text,',','.', [rfReplaceAll, rfIgnoreCase])));

If ‘EditMeanPiecesPerWeek’ is 400, then the mean value is (7*24*60*60)/400 = 1512, which is correct. Below are the inter arrival times for the bags of plastics, of a random sample taken from a simulation run:

578807.45 Generator holds until 580454.14 -> Inter arrival time is 1646.69 580454.14 Generator holds until 580458.05 -> Inter arrival time is 3.91 580458.05 Generator holds until 581159.93 -> Inter arrival time is 701.88 581159.93 Generator holds until 582420.62 -> Inter arrival time is 1260.69 582420.62 Generator holds until 582485.84 -> Inter arrival time is 65.22 582485.84 Generator holds until 583752.69 -> Inter arrival time is 1266.85 583752.69 Generator holds until 585805.41 -> Inter arrival time is 2052.72 585805.41 Generator holds until 585809.07 -> Inter arrival time is 3.66 585809.07 Generator holds until 587312.93 -> Inter arrival time is 1503.86 587312.93 Generator holds until 588971.45 -> Inter arrival time is 1658.52 588971.45 Generator holds until 589139.29 -> Inter arrival time is 167.84 589139.29 Generator holds until 591591.90 -> Inter arrival time is 2452.61 591591.90 Generator holds until 594985.78 -> Inter arrival time is 3393.88 594985.78 Generator holds until 595001.44 -> Inter arrival time is 15.66 595001.44 Generator holds until 595313.83 -> Inter arrival time is 312.39 595313.83 Generator holds until 595813.03 -> Inter arrival time is 499.2 595813.03 Generator holds until 600422.75 -> Inter arrival time is 4609.72 600422.75 Generator holds until 600494.56 -> Inter arrival time is 71.81 600494.56 Generator holds until 601746.18 -> Inter arrival time is 1251.62 601746.18 Generator holds until 601915.22 -> Inter arrival time is 169.04 601915.22 Generator holds until 604704.44 -> Inter arrival time is 2789.22 604704.44 Generator holds until 605276.41 -> Inter arrival time is 571.97 [gap during truck pickup]

612911.91 Generator holds until 617135.00 -> Inter arrival time is 4223.09 617135.00 Generator holds until 619902.42 -> Inter arrival time is 2767.42 619902.42 Generator holds until 622001.26 -> Inter arrival time is 2098.84 622001.26 Generator holds until 625578.29 -> Inter arrival time is 3577.03 625578.29 Generator holds until 625909.23 -> Inter arrival time is 330.94 625909.23 Generator holds until 629147.57 -> Inter arrival time is 3238.34 629147.57 Generator holds until 629225.82 -> Inter arrival time is 78.25 629225.82 Generator holds until 630843.49 -> Inter arrival time is 1617.67 630843.49 Generator holds until 631659.54 -> Inter arrival time is 816.05 631659.54 Generator holds until 636201.05 -> Inter arrival time is 4541.51

Average inter-arrival time of 32 samples : 1554.9, close to the expected mean of 1512.. Without doing a goodness-of-fit test, it shows that the Tomas distribution is being called correctly. As the Tomas

(15)

13

6 Results

The goal of the simulation was to calculate whether the as-is situation of recycling waste could be improved by also collecting waste at fuel stations. Most citizens of a city would save fuel while recycling, because they have to visit a fuel station once in a while anyways. Therefore, no special trip to the recycling center or waste drop-off point would be necessary. This saves fuel, and thus CO2 emissions.

This reduction in emissions can help municipalities reach their sustainability goals. However, a truck is necessary to pick up the garbage from the fuel stations and deliver it to the drop-off point, which costs fuel and CO2. Which situation is more sustainable follows from the results of the simulation.

The city of Amstelveen, The Netherlands is used as a model city to acquire default data from. Using Amstelveen as input, and a standard garbage truck (15m2) with a weekly drive, the output of the simulation is as follows:

The fuel saved in the new situation is 609.29L per month, CO2 saved is 1096.72kg. Monetary and emission savings are small.

During the run, the truck was filled to its maximum capacity multiple (4) times. Recommended is to use a larger truck. Alternatively, the truck may drive more frequently, but this will significantly increase fuel use.

The inventories (fuel stations) were available for just 93.4% of the customers, so larger or more inventories are recommended.

When adjusting for the feedback (using a larger truck of 20 m2, and adding a cooperating fuel station), the following result is achieved:

During the run, the truck was filled to its maximum capacity multiple (3) times. Recommended is to use a larger truck. Alternatively, the truck may drive more frequently, but this may significantly increase fuel use, depending on the driving distances.

The inventories (fuel stations) were available for 99.5% of the customers, which is an acceptable service level.

Adding a fuel station had the desired effect of improving the service level. Making the truck larger also saved some extra fuel because the truck did not have to return to the depot halfway during its route to empty itself, but only once (4 to 3). To fix the problem of the truck filling up during its run, we adjust by using the default truck again (15m2) but now letting it drive every 3 days. The results are:

During the run, the truck was never filled to its maximum capacity. The maximum Payload size was: 10.5 of 15 m3. If possible, it is recommended to use a smaller truck and/or drive less frequent, otherwise this is optimal.

(16)

14

The inventories (fuel stations) were never filled to maximum capacity, so fuel stations may use smaller inventories.

The CO2 savings are slightly smaller because the truck drives more often. However, because now the

problem of filling up is fixed, some CO2 is also saved, because the truck doesn’t return to the depot

halfway its run at all anymore. Because the payload of both the truck, and the inventories of the fuel stations were never filled, this situation is optimal.

In summary, for Amstelveen, with 400 bags of plastics dumped per week, the optimal situation is when at least 6 fuel stations cooperate, and a default sized garbage truck drives every 3 days to pick up the garbage. This saves 1073.91kg per month.

This is a very small saving. The saved amount of CO2 is equal to what a small car emits after driving

10.000km (100gr CO2/km * 10.000km = 1000kg). Therefore, it is not worth for any municipality to invest

(17)

15

7 Conclusion

The to-be situation improves the as-is situation by savings 1073.91kg of CO2 emissions per month. This is

very small, and not worth an investment.

The simulation itself is a verified program, which shows a flexible approach to logistic problems. The Google Maps integration makes it possible to model many urban logistical systems. The output of standard a cost matrix makes it easy calculate the costs of a logistical system in many locations. In this case, the 2-OPT TSP algorithm calculates a near-optimal solution quickly. The simulation itself uses TOMAS, which provides functions and procedures for the generation of flowing elements and inventories, as well as a kernel for event scheduling.

8 Recommendation

The simulation program itself could be made even more flexible by adding the possibility of more pickup trucks, and routing algorithms. However, doing this would approach the creation of a full-scale logistical solution application, and it would be better to design such a program from the ground up.

The real gain is to take the novel idea of this simulation (namely: getting a cost matrix from a list of addresses), and the other interesting algorithms (2-OPT TSP), and put the code of these in an online website/database for use by logistical students of TU Delft. Many other simulations have also been made by students for this course, and a lot of them containing a different interesting algorithms. These can be operations research algorithms (Dijkstra, TSP, VRP, Simplex, etc) or otherwise smart ideas. Combined with TOMAS, these snippets of code can be combined into a powerful toolbox for Delphi.