Master Thesis: Making the right New Product...

Making the right New ProductDevelopment decisions for an

optimal Supply Chain

by Mathijs van Suilichem

Eindhoven, April 2, 2012

Ing Mathijs van Suilichem

Student Identity Number 0571015

In partial ful�llment of the requirements for the degree of

Master of Science in Innovation Management

Supervisors

Prof. Dr. E.J. NijssenProf. Dr. A.G. de Kok

TU/e - ITEMTU/e - OPAC

In cooperation with: ASML

TUE. School of industrial engineering.Series Master Theses Innovation Management.

Subject headings: new product development, real options analysis,supply chain performance, decision tree, lattice tree, supply chain risk

Acknowledgement

No Master Thesis is the work of one person only and of course the work before you is noexception. Many people have contributed in their own way and this page is therefore dedicatedto them.

To start, I like to thank my supervisors Prof. Dr. Ed Nijssen and Prof. Dr. Ton de Kok whohave devoted some of their time to mentor me and give feedback on the subject. Ed challengedme with his ideas and coached me through the process of writing a thesis. Ton's contagiousenthusiasm about the subject and his mathematical insights provided fuel for my "modelingengine".

Jochen Schellekens and Kuno Huisman from ASML gave me worthy feedback on the conceptsof this thesis and on my modeling e�orts. Earlier on, Jacob Jan Paulus and Marcel van Vuurenfrom CCM also helped getting my head around the subject. And of course my fellow studentwho studied partly the same type of literature, Ties van Bommel has given me feedback on mywork. I thank you all.

On the ASML side of things there are several people that helped to make a �t between theoryand ASML practices and spent time to talk about the issues that this thesis is about. I wouldlike to thank: Technical Supplier Manager Ruben Kok (who also provided me with ASML timeto work on my thesis), Technical Supplier Manager Marcel Heezius, Manager of the SupplierEngineering and Outsourcing department Theo Modderman, and supply chain engineers HermanHo, Bart Bovers, and Fred van den Bogaard.

Too much family and friends have seen me less often than I would like and there is nothingmore to say then thank you for your understanding. There are a few people however who wereeven more impacted by this thesis. Especially because it was preceded by a complete studyprogramm that they had to support. Of course this is my family. I thank Norah van Suilichemfor putting up all of here 3 years with a dad studying. The same goes for my son Tobias vanSuilichem who regularly came to the attic to e.g. call me for lunch for his entire life. And �nallyI thank Carin who has not only reviewed my work but has also given me moral support and theopportunity to study.

To all of you, I bow!

3

Contents

1 Summary 9

2 Introduction 112.1 Context ASML: The company and its market . . . . . . . . . . . . . . . . . . . . 112.2 Problem and research statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.3 Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.4 Contribution to literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.5 Contribution to practice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.6 Thesis Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3 Methodology 173.1 Interview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.2 Literature review . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.3 Model development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.4 Interviews and review of documentation . . . . . . . . . . . . . . . . . . . . . . . 183.5 Model application development and testing . . . . . . . . . . . . . . . . . . . . . 19

4 NPD Decision making and Early Supplier Involvement 204.1 Real Options applied to NPD decisions . . . . . . . . . . . . . . . . . . . . . . . . 20

4.1.1 NPD Project valuation through Real Options . . . . . . . . . . . . . . . . 204.1.2 NPD decision support by real option valuation . . . . . . . . . . . . . . . 214.1.3 Usability and limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.2 Early Supplier Involvement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.2.1 Bene�ts of ESI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.2.2 Limitations of ESI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

5 Model development 275.1 The essence of the model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275.2 Model Concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

5.2.1 Adding supply chain performance . . . . . . . . . . . . . . . . . . . . . . . 275.2.2 Improving the improve option . . . . . . . . . . . . . . . . . . . . . . . . . 30

5.3 Mathematical model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305.3.1 Adding supply chain parameters . . . . . . . . . . . . . . . . . . . . . . . 305.3.2 Modeling the decision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305.3.3 Modeling decision impact . . . . . . . . . . . . . . . . . . . . . . . . . . . 315.3.4 Modeling the performance . . . . . . . . . . . . . . . . . . . . . . . . . . . 315.3.5 Modeling the value de�nition . . . . . . . . . . . . . . . . . . . . . . . . . 31

5.4 Limitations for implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

6 De�ning Supply Chain Performance 336.1 Supply chain performance indicators . . . . . . . . . . . . . . . . . . . . . . . . . 33

6.1.1 Quality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346.1.2 Logistics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356.1.3 Technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366.1.4 Cost of Goods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4

CONTENTS

6.2 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

7 Application and testing 387.1 Software Implementation of Model . . . . . . . . . . . . . . . . . . . . . . . . . . 38

7.1.1 Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387.1.2 User input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

7.2 Limitations of the implementation . . . . . . . . . . . . . . . . . . . . . . . . . . 417.3 Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

7.3.1 De�ning a test project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427.3.2 Running the test project . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437.3.3 Discussion of results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447.3.4 Sensitivity analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

7.4 Findings and limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477.5 Recommendations for implementation . . . . . . . . . . . . . . . . . . . . . . . . 48

7.5.1 Dealing with limitation 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.5.2 Dealing with limitation 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.5.3 Dealing with limitation 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.5.4 Dealing with limitation 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . 497.5.5 A di�erent approach for implementation . . . . . . . . . . . . . . . . . . . 49

8 Conclusion 518.1 Research question, goals and �ndings . . . . . . . . . . . . . . . . . . . . . . . . . 518.2 Implications for literature and practitioners . . . . . . . . . . . . . . . . . . . . . 52

8.2.1 Literature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528.2.2 Practitioners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

8.3 Limitations and recommendations . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

Appendices 56

A Abbreviations 57

B Details on improvement impact 58

C Calculations to aid in Model automation 60C.1 Number of End nodes for continue . . . . . . . . . . . . . . . . . . . . . . . . . . 60C.2 Scale of performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60C.3 Expand scale to include improve option . . . . . . . . . . . . . . . . . . . . . . . 61

D Sensitivity tests 64

E Source code 69E.1 Main.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69E.2 Project.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69E.3 Connection.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72E.4 DecisionTree.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73E.5 TreeNode.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85E.6 EndNode.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86E.7 IntermediateNode.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87E.8 Location.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90E.9 NetworkCanvas.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91E.10 ProjectPanel.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92E.11 ReviewPanel.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100E.12 Review.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

5

CONTENTS

E.13 Tree.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106E.14 ValueCalculator.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107E.15 YieldCalculator.java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

6

List of Tables

2.1 Figures describing ASML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.1 Search terms per literature stream . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4.1 In�uence of Variability on Value . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

6.1 Example MQP rating . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

7.1 Overall project data - simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . 427.2 Review data - simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

8.1 Improvements of our model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

A.1 Abbreviations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

D.1 Overall project data - sensitivity tests . . . . . . . . . . . . . . . . . . . . . . . . 64D.2 Review data - sensitivity tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

7

List of Figures

2.1 Project �ow with supplier involvement . . . . . . . . . . . . . . . . . . . . . . . . 14

4.1 Lattice Tree Model for a learning Option - Huchzermeier and Loch (1999) . . . . 22

5.1 Old model: Relations between value drivers . . . . . . . . . . . . . . . . . . . . . 285.2 Adapted relations of the performance and requirements drivers . . . . . . . . . . 29

6.1 Construction of Supply Chain Performance . . . . . . . . . . . . . . . . . . . . . 336.2 Value Curve of a part . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

7.1 User input on a project level . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397.2 Project hierarchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407.3 User input on the review parameters . . . . . . . . . . . . . . . . . . . . . . . . . 417.4 Software output of the test project . . . . . . . . . . . . . . . . . . . . . . . . . . 437.5 Decision tree test project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447.6 Decision tree according to old model . . . . . . . . . . . . . . . . . . . . . . . . . 457.7 Decision tree according to old model, withabandon option . . . . . . . . . . . . . 457.8 Di�erent approach for implementation . . . . . . . . . . . . . . . . . . . . . . . . 49

B.1 Transition probabilities of product performance as de�ned by Huchzermeier andLoch (2001) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

B.2 Impact of improvement independent from time and current performance . . . . . 59

C.1 Tree with di�erent n's, T = 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61C.2 Projecting the expert's opinion on the tree scale . . . . . . . . . . . . . . . . . . . 61C.3 Function to describe relation of tree values with Yield . . . . . . . . . . . . . . . 62

D.1 All improvement cost set to e100 . . . . . . . . . . . . . . . . . . . . . . . . . . . 64D.2 All improvement cost set to e800k . . . . . . . . . . . . . . . . . . . . . . . . . . 65D.3 All improvement percentages set to 80% . . . . . . . . . . . . . . . . . . . . . . . 65D.4 All improvement percentages set to 5% . . . . . . . . . . . . . . . . . . . . . . . . 65D.5 All Nr of Next Possible States set to 2 . . . . . . . . . . . . . . . . . . . . . . . . 66D.6 All Nr of Next Possible States set to 5 . . . . . . . . . . . . . . . . . . . . . . . . 67D.7 All improvement cost set to e120k, all improvement percentages to 30% . . . . . 68

8

1. Summary

Planning and dealing with risk during a new product development (NPD) project, is an impor-tant area of research. The real options theory is an often used example of how to deal with (non�nancial) risk (Kodukula and Papudesu, 2006; Santiago and Vakili, 2005; Mathews, 2009). Realoption theory applied to NPD project risk provides a method to value an NPD project includingthe managerial �exibility to choose between di�erent paths to project completion. The optionto improve a new product development project is a particular useful addition to real optionsthat was introduced by Huchzermeier and Loch (2001).

To date however this research does not include considerations of risk regarding supply chain.Value drivers that are identi�ed are; cost, time, product performance, market payo� and marketrequirements. However, including supply chain variables is important to prevent new productdevelopment decisions that lead to unfavorable supply chain situations in volume production.

On the other hand there is a lot of research done on early supplier involvement (ESI) thatfocuses on the vertical integration of manufacturer and supplier at an early stage of NPD (Bidaultet al., 1998) to improve the design based on the knowledge of suppliers.

However, this research on ESI by de�nition does not involve improving a design for the supplychain prior to the choice and involvement of suppliers. Furthermore ESI does not consider wetherthe available knowledge of the suppliers involved can and is always applied.

Our research focuses on the situation where supply chain risk is identi�ed during new productdevelopment but the information is discarded because its impact or chance of occurrence isunderestimated. Regardless wether or not a supplier is already involved.

The objective of this thesis is to �nd a way to assess the impact of a supply chain issue whenmaking new product development decisions. To give direction to this objective we de�ne goalsto develop a model and a software implementation of that model.

We use information from interviews with experts at the semiconductor equipment manufac-turer ASML, to build our model and test our implementation.

We �nd that supply chain performance can be measured through the parameters Quality,Logistics, Technology and Cost (QLTC). The model that we build upon has a multi dimensionalperformance parameter that represents Technology. We have used this multi dimensionality toadd the supply chain performance parameters Q, L and C to the model.

Since we aim at balancing all parameters Q,L,T and C to come to the best overall NPDdecision, we model the in�uence of those parameters on eachother. We have to come up with ourown approach for this since the models from Huchzermeier and Loch (2001) and more particularfrom Santiago and Bifano (2005) consider the dimensions of performance to be independent.

While gladly adopting the option to improve upon a development project, we also changethis concept in our model. This is because we state that the impact of an improvement actionis dependent on the timing of this action and the current performance. Intuitively it is easierto improve early on in a project compared to at the �nish and it is also easier to improve on apoor performance then on a near perfect performance.

To be able to make an implementation of our model we developed a way to express supplychain performance in �nancial terms based on some de�nitions originally used by ASML toassess their supply chain. With these de�nitions we develop a software tool that is able to assessa quality related design issue. We show how such a tool could work and test its general behavioras well as how it behaves in relation to current models. Finally we test the tool with someextreme values to show the sensitivity of the tool.

We contribute to literature by adding a supply chain component to the real options approachfor dealing with risk during new product development.

9

CHAPTER 1. SUMMARY

We emphasize the overlooked importance to include the in�uence that the dimensions of amulti dimensional performance have on eachother. In other words, an improvement of qualitymight also improve cost but lengthen order lead time.

A di�erent approach for the impact of an improvement during NPD is o�ered that includesthe in�uence of timing and current performance.

Finally, by developing a software implementation of our model we show what limitationshave to be dealt with in practice and test the applicability of the theoretical model.

The contribution to practice can be found in creating awareness of the need for rightfullyassessing a supply chain related issue during new product development.

Second we created prototype software of which the source code is included and that can befurther developed to become a practical decision supporting tool for NPD projects.

Finally we o�ered an approach to express supply chain performance based on our researchat ASML.

10

2. Introduction

In this chapter we will explain the fundamentals of our research in four steps.First we will introduce the problem de�nition as well as both the company and market

situation in which the research is placed. Company key �gures are discussed together withsome aspects of the market situation it operates in. We will then present the problem as it wasoriginally discussed and evaluate the description of the issue to come to a problem descriptionthat will be the base of further investigation.

Second we will de�ne the goal of the research and make the research statements that areinvestigated. This is the base on which the rest of the research is built.

In the third part of this introduction, we will discuss the contribution this research has toboth literature and practice.

Finally the last section will explain how the rest of this thesis is structured.Before we really dive into the subject let me note that a lot of abbreviations were used

throughout this thesis and a summary of them was put in appendix A to support the reader.

2.1 Context ASML: The company and its market

In this �rst section about ASML we will give some information about the company itself and thelithography industry in which ASML operates. This will create a context for the problem thatis described in the next section, and will thus lead to a better understanding of the problem.

The ASML website(ASML, 2011a) opens with the following description of ASML:

"ASML is one of the world's leading providers of lithography systems for the semicon-ductor industry, manufacturing complex machines that are critical to the productionof integrated circuits or microchips. Headquartered in Veldhoven, the Netherlands,ASML designs, develops, integrates, markets and services these advanced systemswhich continue to help our customers - the major chipmakers - reduce the size andincrease the functionality of microchips and consumer electronic equipment."

Some �gures to describe the size of the business and the company ASML are stated in table 2.1and are based on the year 2010(ASML, 2010) and 2011(ASML, 2011b). The employee data of2011 is based on the �rst half year of 2011.

Employees 2010 Financials 2010Payroll Temporary Net sales Operating income Net income> 7100 > 2000 4,507.9 million 1,250.7 million 1,021.8 million

Employees 2011 Financials 2011Payroll Temporary Net sales Operating income Net income7697 2159 5,651.0 million 1,641.2 million 1,467 million

Table 2.1: Figures describing ASML

ASML has a market share of over 70% and is able to stay ahead of the competition byo�ering the latest technology of equipment that can help produce the smallest chips possible.ASML can thus be seen as the technology leader of the market. The two most important otherplayers are Nikon and Canon.

Since all products of ASML are situated in one market, the lithographic industry, the develop-ment and characteristics of this market are crucial to the way that ASML drives its businesses.

11

CHAPTER 2. INTRODUCTION

An important aspect of this market is the ITRS or "International Technology Roadmap forSemiconductors" that is sponsored by �ve organizations representing �ve regions in the world;ESIA (European Semiconductor Industry Association), JEITA (Japan Electronics and Infor-mation Technology Industries Association), KSIA (Korean Semiconductor Association), TSIA(Taiwan Semiconductor Industry Association) and SIA (United States Semiconductor IndustryAssociation) (ITRS, 2011).

The objective of the ITRS is

"to ensure cost-e�ective advancements in the performance of the integrated circuitand the products that employ such devices, thereby continuing the health and successof this industry"(ITRS, 2011)

On their website, the ITRS publishes documents with their view on how the industry shoulddevelop, what challenges it will face etc.

An important driver of the technological progress in this industry has long been "Moore'sLaw". This "Law" originates back to a paper by Gordon Moore from 1965 in which he statedthat the number of components that could be integrated in an IC would increase exponentiallyover time (Moore, 1965). Since 1970 the number of components per chip has doubled every twoyears (Arden et al., 2010).

Together with this development of chips becoming smaller and more capable, there is a pricecorrosion on chips. This leads to the necessity for the chipmakers to deliver smaller and morecapable chips in order to maintain pro�tability. So for a manufacturer of chips it is importantto be able to stay on track with the lithography roadmap in order to keep pro�ts at the rightlevel. And to do so, often the newest machines of ASML are needed.

To be able to support the chipmakers in their strategy, it is very important for ASML tobring their products to the market at the right moment. Time to market and latest technologyare the factors that discriminate ASML from its competitors.

The process of developing and launching a new product is called New Product Introduction(NPI) at ASML. During an NPI there is a lot of focus on designing the latest technology thatcan support the manufacturing of the newest generation of chips. The emphasis on technologyis needed because an NPI often involves not only recombining existing processes and technology,but also inventing new processes and unproven technology. This is what de�nes the technologyleadership of ASML. On the other hand, there is a lot of focus on bringing the product to themarket in time for the before mentioned reason of enabling the customers of ASML to keep inpace with the technology roadmap.

With timing and technological feasibility as the main focuses, it is hard to also keep otherimportant things like manufacturing quality, logistics and costs under control. As the nextsection will show, this di�culty is an important starting point for our research.

2.2 Problem and research statement

The subject of this study originated in a department called Industrial Engineering and morespeci�cally the sub department called "Supplier Engineering & Outsourcing", in short SEO.SEO evolves around quality and technical matters within the supply chain of ASML.

During a new product introduction (NPI) the engineers working in SEO have the goal toenable the supply chain to deliver products with a high quality that is both repeatable andreproducible. To achieve this goal, SEO works together with both the ASML developmentdepartment and the supplier in order to come to a manufacturable design and a repeatable andreproducible manufacturing process.

In interviews, people involved in NPI's, stated that design issues regarding the supply chainwere identi�ed early in the project on a regular base. However, it was often decided to pro-

12


ceed without improvement because of either project timing or technical di�culty to prevent theproblem.

When the volume design is ready, the NPI is �nished or almost �nished and the projectteam is small, non existing or there is only a "sustaining" group of people that can providedevelopment support in case of problems. At this point, things are sometimes far from perfectand people �nd themselves wondering how certain situations came to exist. These situations aredi�erent in nature and following are some generalized examples found in ASML:

• Supplier "A" can not deliver the right quality, due to bad manufacturability of the newproduct or component design

• There is a very small supplier "B" for which there is no alternative possible with thecurrent design

• Expensive product "X" has an extremely long lead time, leading to large stocks of un�n-ished products (Work In Process)

• Product "Y" needs many sequential critical production steps, adding up to a large Yieldloss

• Product "Z" is very expensive due to the exotic material choice made

The design is reviewed through various processes at ASML involving the following partiesbesides the development engineer for di�erent aspects of the design.

• CostA Purchasing Account Manager (PAM) and Cost Engineer (CE) evaluate the design oncost where the PAM focuses on the commercial agreements with the supplier and the CEfocuses on the cost of the product design

• LogisticsA Logistical Supply Manager (LSM) evaluates the design on aspects that negatively in�u-ence needed stocks and order lead time

• QualityA Supply Chain Engineer (SCE) from the SEO department evaluates the design on aspectsof manufacturability and testability

Depending on the timing of these reviews, the supplier is also involved.Despite these design reviews on the various topics, the analysis of the root cause of the issues

mentioned previously often leads back to the design. E.g. it was the design that was impossibleto manufacture, it was the design that forced us to deal with this supplier. The design neededa lot of manufacturing steps at di�erent suppliers leading to a long supply chain with manymanufacturers involved and a very long lead time. As was explained earlier, there are peopleinvolved from other departments besides R&D like purchasing, logistics1 and before mentionedSEO.

Figure 2.1 shows one example of a process at ASML where issues are identi�ed during areview but might be neglected. In this speci�c example the supplier is already involved andreviews the design to help make it �t for the supply chain.

The design of ASML is documented in Technical Product Documentation (TPD). We see in�gure 2.1 by the dashed line between "Concept Design" and "Review (TAS)" the �rst reviewwith the supplier. This review is called TAS which is short for TPD Acceptance by Supplier.The second review is called PER which stands for Proto Evaluation Report. We will now explainthis process in more detail.

1Logistics in this case evolves around the logistics of incoming goods.

13


FunctionalDesign

ConceptDesign

ProtoDesign

VolumeDesign

Review(TAS)

Review(PER)

ProtoProduction

VolumeProduction

Figure 2.1: Project �ow with supplier involvement

The parties involved in our example are the supplier, the ASML development departmentand the ASML supply chain engineer.

An NPD project at ASML follows the steps from left to right with the purple steps showingthe states of the design, the green steps showing the states of production and the yellow doc-uments representing the documented design reviews. The dashed lines indicate an information�ow.

The �rst review of the design by the supplier takes place when there is a concept design andno production has been done. This is a review based on the available drawings (dashed arrowfrom "Concept design" to "Review (TAS)") and it results in a TAS. This TAS is �lled in bythe supplier with remarks about e.g. manufacturability, logistics and cost. The remarks on theTAS involve identi�cation of an issue and preferably a proposal how to solve the issue.

The remarks in this �rst review (TAS) are reviewed by ASML and are implemented in theProto design or are discarded with an explanation.

With the information from the TAS and with the concept design �nished, a "Proto Design"is developed and "Proto Production" takes place. Now the supplier has information from theproto design as well as from his �rst prototype production run. This is depicted by the dashedarrows from "Proto Design" and "Proto Production" to "Review (PER)". The information isused for a second review that is called a PER or Proto Evaluation Report.

Analog to TAS, the supplier �lls the PER report with his remarks which are reviewed byASML and implemented in the volume design or discarded with an explanation.

Discarding the remarks made on the TAS and PER are examples of neglecting issues becausetheir impact or chance of occurrence is unclear. Afterwards when not only the issue, but alsothe impact was clear, these decisions sometimes prove to be wrong.

The core problem illustrated by our example is inadequate risk assessment. A design decisionis made during new product development and the available information about the future supplychain situation is discarded because the impact or chance of occurrence is underestimated.

We now rephrase the problem at ASML to the following:

During New Product Introduction, a supply chain issue attributable to the design

is identi�ed whose chance of occurring and impact is underestimated. Given timingpressure on the project or technical di�culty of the design, the inappropriate decisionis taken not to improve the design on this aspect.

During New Product Introduction, a supply chain issue attributable to the design

is identi�ed whose chance of occurring and impact is underestimated. Given timingpressure on the project or technical di�culty of the design, the inappropriate decisionis taken not to improve the design on this aspect.

Problem Statement I

Rephrasing the problem as such immediately gives us the following research statement thatwill be the base of this thesis:

14


How can we improve the assessment of a supply chain issue to make New ProductDevelopment decisions that ultimately prevent unfavorable supply chain situations?How can we improve the assessment of a supply chain issue to make New ProductDevelopment decisions that ultimately prevent unfavorable supply chain situations?

Research Question I

Here a supply chain issue is something that can be identi�ed during new product developmente.g. a design that is hard to manufacture. A supply chain situation is what is the �nal resultof the supply chain issue e.g. a bad product yield. Examples of (unfavorable) supply chainsituations at ASML were mentioned earlier.

In the next section we will de�ne two research goals that address the problem and researchstatement.

2.3 Goals

The core of the problem as it was described by problem statement 1 is decision making during

an NPI that leads to non optimal results regarding supply chain performance. We de�ned twogoals that are both attacking this core:

Develop a model that includes supply chain interests and helps assess NPD decisionson their impact on project performance. This model should aid in �nding the decisionthat optimizes the project performance including supply chain performance.

Develop a model that includes supply chain interests and helps assess NPD decisionson their impact on project performance. This model should aid in �nding the decisionthat optimizes the project performance including supply chain performance.

Goal I

The model must be a mathematical approach of the problem but one that does not necessarilycapture all aspects of the problem, leading to the ultimate and perfect answer. Rather it shouldo�er insight in the situation and thus support the existing decision making process. In order tobuild on this model and be able to actually use it, the following goal is de�ned as deliverable ofthis research.

Create a software tool that is an implementation of Goal 1 to enable two things; testthe model and serve as a tool for the decision making process itself.Create a software tool that is an implementation of Goal 1 to enable two things; testthe model and serve as a tool for the decision making process itself.

Goal II

This software tool does not necessarily have to be a perfect fool proof software programm, butit does have to be able to show the decision process and outcome of the model. It should alsobe �t for scenario testing to strengthen this research.

2.4 Contribution to literature

Planning and dealing with risk during a new product development project, is an importantarea of research. An often used method to cope with this is the real option theory (Kodukulaand Papudesu, 2006; Santiago and Vakili, 2005; Mathews, 2009). With real options theory itis possible to valuate a new product development project including the managerial �exibility totake decisions that steer the projects direction based on intermediate results.

Huchzermeier and Loch (2001) have proposed a real options model, later also improved bySantiago and Vakili (2005) and by Santiago and Bifano (2005), that describes the valuation ofnew product development projects on subsequent moments in time. By doing so they are able tocapture the value of the managerial �exibility to steer the project. Furthermore, this model can

15


be used for decision making because it calculates the project value for all decisions and choosesthe optimal decision.

Attractive as that sounds as an approach to our problem, there has been no earlier attentionwithin this stream for supply chain performance.

The contribution to literature is threefold.First, supply chain issues are addressed using a real option approach to model new product

development decisions. Using the real options model to assess supply chain performance as partof NPD project performance is a new application of the real options model.

Second, we translate the real options concept via a mathematical model into an actualsoftware application thereby evaluating the model. This will o�er two new insights not only onour adaption, but also on the model as it is already known. It will o�er a new insight into thein�uence that various parameters of the model have on eachother. It will also o�er a new insightconcerning the "improvement option" that was introduced within the real option literature as away to improve the potential of an investment.

2.5 Contribution to practice

Our contribution for practitioners is twofold.First we o�er an approach how to operationalize the concept of supply chain performance in

order to make it measurable and use it in a model.Second, we develop prototype software that can be further developed in order to come to a

tool that can be used for actual decision support. The prototype software is �t for practitionersto already test its use for decision support before deciding to further develop the software. Thesource code is made available in appendix E for information and further development.

2.6 Thesis Structure

The way this thesis is structured is as follows.Now that the goals and research statements are set, chapter 3 will show the methodology

used in this research.After that chapter 4 discusses some literature that focuses on the problem from two angles;

Early Supplier Involvement and Real Option Analysis in the context of new product develop-ment. When this literature is discussed, it becomes clear that the main focus will be on the realoption analysis that can tackle the core of the problem: decision making.

With the knowledge gained from literature and the choice for a theoretical base that canhelp solve the problem, the next step is to develop our own model based on the real optionsmodel that we found. This is captured in Chapter 5.

Because we want to develop an actual implementation of our model, we need to deepen theunderstanding of how the ASML situation can be de�ned in the terms of the model that wehave developed. Chapter 6 covers this by presenting the �ndings from interviews at ASML.

7 covers the actual development of the software application. We describe the requirements wespeci�ed and explain how this was implemented. After that an example project is run followedup by some tests regarding the sensitivity of the application.

Chapter 8 concludes this thesis by discussing the �ndings, limitations and recommendationsfor further research.

16

3. Methodology

3.1 Interview

The �rst step of this thesis is aimed at formulating a problem statement by getting enoughinformation about the issue that is identi�ed at ASML. This was done through unstructuredinterviews of which the results are described in section 2.2. The choice for using unstructuredinterviewing is based on the fact that at this stage we are exploring the problem and do nothave a �xed set of prede�ned questions.

The issues from which the research question originated are identi�ed in the Supplier Engi-neering and Outsourcing (SEO) department.

During interviews with the SEO manager and a Technical Supplier Manager (TSM), theinterviewees are asked to explain the problem and mention several examples that illustrate theidenti�ed problem. Those examples were introduced in section 2.2.

With this �rst step to identify and learn about the issue subject to this research and ourresearch question de�ned, our next step is to review literature and look for knowledge that canhelp solve the problem.

3.2 Literature review

To investigate what is known in literature about the problem of decision making during newproduct development and supply chain interests, a literature review is executed.

Two �elds of research are identi�ed that potentially will be able to (help) solve the problem.Those are "Early Supplier Involvement" (including design for manufacturability and assembly)and "Real Option Analysis".

Early Supplier Involvement or ESI evolves around cooperating with the supply chain duringnew product development while ROA concerns decision making during new product develop-ment.

To �nd literature on both subjects, several search engines are used e.g. "Google Scholar","Proquest", "Sciverse ScienceDirect", "JSTOR", "Web of Science", "Wiley Online Library","Emerald" and "IEEE Xplore". Some terminology used for the searches are summarized persubject in table 3.1.

ESI ROA

Early Supplier Involvement Real OptionsESI ROA

Design for manufacturability ROV1

DFMA

Table 3.1: Search terms per literature stream

The search terms are used independently, together and all combined with the search terms"New Product Development" and "NPD".

Initially the search only looked for literature published after 01-01-2000. However the refer-ence lists of these papers were screened for additional relevant papers which led to both earlierpublications as well as literature that would not have been found with the search terms men-tioned.

17

CHAPTER 3. METHODOLOGY

The search results were screened on how many times they were quoted. No hard criteriawere used to �lter on this because this would discriminate the most recent papers in theirdisadvantage.

The papers that were found were critically reviewed and commented from the point of viewof this research. Therefor this chapter is not an attempt to be a complete literature researchbut rather a selection of work that can be used for this thesis.

3.3 Model development

From our review we learn that real option theory applied to NPD as introduced in section 2.4o�ers a modeling approach that is a solid base to adopt and make suitable for our research.Therefor our next step is the development of a model based on this.

The development of our model is done in two stages that contribute as follows:

1. Conceptual modelThis step is needed to understand how supply chain interest can be addressed with anexisting model from literature. In other words, where does it �t in the existing model

2. Mathematical modelWith the concept de�ned, we will show the mathematical implications of this and alter-ations to the existing model

The conceptual model refers to a graphical representation of the existing model that isadapted to include our supply chain interests. We explain how the parameters of the currentmodel are related and what the best way is to integrate a supply chain parameter.

To o�er a base for an implementation of the model and thus be able to actually use itfor calculations, a mathematical model is developed that represents the alterations that weredepicted in the conceptual model.

3.4 Interviews and review of documentation

Since we also set a goal to develop an actual implementation of the de�ned model, we narrow ourfocus to ASML as a test case. Doing so makes it possible to come to clear de�nitions regardingsupply chain parameters that we can use for calculations. At the same time it o�ers a proposalhow other companies might use the model.

We need to deepen our understanding of the problem at ASML that supply chain issuesare underestimated when decisions are taken during NPD. To do so, we conduct structuralinterviews to de�ne the problem of ASML in the terms found in literature.

The reason to choose for structural interviews is that we want an outcome in terms of whatwe found in literature. More speci�cally the questions are aimed at expanding the model ofHuchzermeier and Loch (2001).

The interviewees are experts that participate in New Product Development projects fromthe purchasing department, logistical department and SEO department.

An important �eld of interest concerns capturing the value of supply chain performancebecause the model evolves around value drivers of a project. To come to this we focus on gettingan answer on the following questions:

1. How would you de�ne a project in terms of value drivers

2. What parameters determine supply chain performance

3. How are those parameters de�ned

18

CHAPTER 3. METHODOLOGY

Since the �rst question proved hard to answer as an open question, we presented the valuedrivers of the current model and asked if they were applicable to an ASML project. If not, weasked how the ASML situation is di�erent to the situation presented.

To verify the results of the interviews we did a review of ASML documentation on the lasttwo questions. The answer to the �rst question could not be found in ASML documentationand was veri�ed by checking the answers of one interviewee with an other.

3.5 Model application development and testing

To be able to evaluate our model and do some tests with it, we developed a prototype softwareapplication that can be used during an actual decision making process. This implementation isbased on the ASML situation that was investigated with the interviews and review of documen-tation. As a result the scope of this software is narrower than the scope of the model that wasdeveloped.

To evaluate the behavior of our model we simulate a project with input from experiencedparticipants of new product development projects. To avoid intellectual property issues andspending too much research capacity on data gathering, experts are consulted to de�ne imaginarybut realistic project data for the test.

Apart from the simulation of an actual project, the sensitivity of our tool will be tested bychanging some input parameters and assessing the resulting behavior of the tool.

Since the scope of the software is narrower than the initial model, we will explain whatconclusions can be drawn from the tests that we will do with this software and do recommen-dations on the next steps that should be taken to come to a software tool that can be used bypractitioners.

19

4. NPD Decision making and Early

Supplier Involvement

This chapter o�ers a literature review regarding decision making during new product develop-ment. To date this literature that involves real options does not include supply chain relatedrisks, an issue that this thesis does address.

Therefor we will also investigate the �eld of early supplier involvement. Together withknowledge about decision making during NPD, this should provide the right background to �nda solution for the issues found at ASML.

We will �nalize this chapter by presenting our conclusions about what we found in literatureand propose how to proceed to come to the development of our model as de�ned in goal 1.

4.1 Real Options applied to NPD decisions

As stated in chapter 2, planning and dealing with risk during NPD is an important area ofresearch and real option theory is often used to cope with this (Kodukula and Papudesu, 2006;Santiago and Vakili, 2005; Mathews, 2009).

Investment in new product development introduces risk coming from both technological andmarket uncertainty (Wang, 2011). This situation can be compared with �nancial options (Dixitand Pindyck, 1994) and Myers (1977) is credited in literature for being the �rst to see thisanalogy and name this counterpart of �nancial options "real options".

We will now explain more about these real options and how they have been applied to newproduct development projects.

4.1.1 NPD Project valuation through Real Options

The usage of real options within new product development focuses on the (monetary) valuationof these projects. Real Options are not the only way to do this valuation. But opposite tomethods like Discounted Cash Flow (DCF), Net Present Value (NPV) and Internal Rate ofReturn (IRR), Real Options take into account the managerial �exibility to act on informationthat will be gathered during the project (Cobb and Charnes, 2007; Barnett, 2005; Putten andMacMillan, 2004; Davis, 2002; Huchzermeier and Loch, 2001, 1999).

In literature we �nd two usages of Real Options or Real Option Analysis (ROA, not to bemistaken with Return on Asset).

The �rst usage of real options focuses on the selection of the most pro�table new productdevelopments and thus functions as a portfolio management tool (Eckhause et al., 2009; vanBekkum et al., 2009; Wang and Hwang, 2007; Putten and MacMillan, 2004).

The second application of real options can be found in the management of new productdevelopment projects (Wang, 2011; Hongfeng et al., 2008; Barnett, 2005; Santiago and Vakili,2005; Santiago and Bifano, 2005; Boute et al., 2004; Huchzermeier and Loch, 2001, 1999). Inthese applications, the subsequent decisions during the project are considered as points in timewere the project can be valuated (review points). A lattice tree can be drawn to show allpossible paths between those review moments and for every identi�ed state (node in the tree)a best decision can be determined. To determine the best decision, again the valuation of theproject through real options is used.

This second application is an important subject for this paper as it will be the base of themodel developed in chapter 5. Therefore we will discuss it in more depth in the next section.

20

CHAPTER 4. NPD DECISION MAKING AND EARLY SUPPLIER INVOLVEMENT

4.1.2 NPD decision support by real option valuation

A model by Huchzermeier and Loch (2001) that was improved later on by Santiago and Vakili(2005) and by Santiago and Bifano (2005), describes the valuation of a new product developmentthroughout the project. This model can both be used to valuate the managerial �exibility tosteer the project as well as to assess what decision leads to the highest project value.

In this section we will brie�y explain this model, more details can be found in the papersfrom mentioned authors.

Huchzermeier and Loch (2001); Santiago and Vakili (2005) state that new product develop-ment projects build on �ve value drivers:

• Project cost

• Project duration

• Product performance

• Market requirements

• Market payo�

Product performance within this context is de�ned as either one technical characteristic (Huchz-ermeier and Loch, 2001) or several (Santiago and Bifano, 2005) technical characteristics of theproduct e.g. "processor speed".

The value drivers are depicted in the formula for project value V :

V = f(performance, cost, time, market requirement, market payo�)

The in�uence of the variability of these parameters on the total project value is not analogto �nancial options. With �nancial options, an increase in variability increases the value of theoption. As is shown by Santiago and Vakili (2005) this relation is unclear in the case of the realoptions application used by Huchzermeier and Loch (2001).

Value driver Fixed in�uence E�ect of higheron Value variability

Performance No n.a.Cost No n.a.Time No n.a.Market requirements No n.a.Market Payo� Yes Increased Project Value

Table 4.1: In�uence of Variability on Value

Table 4.1 shows for each value driver the in�uence of their variability on the option valuebased on Santiago and Vakili (2005). We can see in this table that only the in�uence of variabilityin Market payo� is known and that a higher variability leads to an increased project value.

Besides providing a de�nition for project value, Huchzermeier and Loch (2001) introducea new option "improve" that is unknown to �nancial options. This option speci�cally appliesto the value driver performance which is determined by the technical part of the developmentprocess. The options beside "improve" are to abandon and to continue the project and are alsocommon with �nancial options.

The improve action is relevant for the value driver performance and represents the possi-bility to expand resources to increase the performance of the project. This performance canbe one dimensional e.g. "processor speed" (Huchzermeier and Loch, 2001) or multidimensional

21


Figure 4.1: Lattice Tree Model for a learning Option - Huchzermeier and Loch (1999)

(Santiago and Bifano, 2005). However, no performance other then the technical function of theproduct is mentioned.

A project is de�ned to have several review moments at which a management decision canbe taken (option executed). To illustrate their model and the impact of the improve option,Huchzermeier and Loch (2001) show the Lattice Tree depicted in �gure 4.1 where it becomesclear that not only the notion of real options shows more value for the project, but the improveoption in particular o�ers the possibility to capture the upside potential of the project.

The tree is created from left to right by drawing all possible paths from review point toreview point were the performance changes due to chance (in this particular tree the chance is50% to do better and 50% to do worse). Then all the decision nodes in the tree are valuatedfrom right to left for the decision that leads to the highest value.

More details on the exact calculation of a decision value can be found in the paper byHuchzermeier and Loch (2001) and will also be clari�ed in chapter 5 when the real option modelis adapted.

In the next section we will further analyze this model and show its usability as well as somelimitations.

4.1.3 Usability and limitations

A good decision supporting model

The attractiveness of the existing real option model lies in the basic idea behind the model thatwe would like to describe as follows:

a decision can be assessed by calculating its impact on the projects monetary value,taking into account the various paths that that project might follow due to bothchance and subsequently made, value maximizing decisions.

How this is established was described previously in section 4.1.2 and is best illustrated bythe lattice tree in �gure 4.1.

22


Although the basic idea behind the model is very useful, there are some limitations that willbe explained in the next sections.

Supply chain issues not included

As was stated earlier, the real option model as presented in section 4.1.2 does not account forsupply chain issues. That is, the value driver performance is presented to only match the productfeatures or technical properties with the customer requirements. It is important to include e.g.quality, on time delivery and cost aspects into the performance.

The model of Santiago and Bifano (2005) is well suited for a broader interpretation of per-formance because they present performance as a multidimensional parameter. But they do nottalk about other implementations than a set of technical design features let alone mention animplementation including supply chain performance.

Concluding, we state the following:

Adding supply chain interests to a real option model is a necessity to come to agood overall decision model that can be used during new product development. In thecurrent model that only refers to the technical performance of a product, the in�uenceof supply chain issues on project value is neglected.

Adding supply chain interests to a real option model is a necessity to come to a goodoverall decision model that can be used during new product development. In thecurrent model that only refers to the technical performance of a product, the in�uenceof supply chain issues on project value is neglected.

Independent multi dimensionality

To make the decision model capable of choosing the best combination of actions on the variousdimensions, the model must take into account the e�ect that an action on dimension 'A' has ondimension 'B'. The current model does not provide in this.

This is especially true in our case where we want to be able to compare the interests ofsupply chain with the interests of the technical speci�cations.

Both Huchzermeier and Loch (2001) and Santiago and Bifano (2005) note that performancecan be a multidimensional parameter and Santiago and Bifano (2005) implement this by intro-ducing the performance as a vector. The improvement impact however, is modeled as a vectorinstead of a matrix thereby neglecting the in�uence of the parameters on eachother.

It is important to note that:

Modeling improvement impact as a vector instead of a matrix implies that the variousdimensions of performance do not in�uence each other. In reality, trade o�s often mustbe made between properties of a product design.

Modeling improvement impact as a vector instead of a matrix implies that the various

dimensions of performance do not in�uence each other. In reality, trade o�s often mustbe made between properties of a product design.

An example is e.g. power and speed versus fuel e�ciency of a car. In some ways both canbe improved but beyond a certain point a choice will have to be made to make a car either morepowerful or more economic.

Fixed improvement impact

For the model to represent an actual new product development project, it has to deal with thefact that the impact of an improvement can change during the project and can also be dependenton the current performance.

23


In the model as introduced by Huchzermeier and Loch (2001) and built upon by Santiagoand Vakili (2005) and Santiago and Bifano (2005), this is not in place and neither of the authorsdiscuss how to deal with this.

It seems unrealistic to think that the impact of an improvement action would be the samethroughout the project. Intuitively, a project that is almost �nished is a lot harder to improvethan a project that just started.

Modeling the impact of the improvement independent from the actual current performanceis also questionable. It should be easier to improve when current performance is extremely badthen it is when current performance is almost perfect.

How we address both remarks will be shown in chapter 5 but at least now we now thefollowing:

Our model needs to enable making the impact of the improvement dependent of boththe current performance as well as the moment in time the improvement action willbe taken.

Our model needs to enable making the impact of the improvement dependent of boththe current performance as well as the moment in time the improvement action willbe taken.

We o�er a more detailed explanation of these limitations in appendix B.

4.2 Early Supplier Involvement

Early Supplier Involvement or ESI has been de�ned by Bidault et al. (1998) as

"a form of vertical cooperation where manufactures involve suppliers at an early stagein the product development/innovation process, generally at the level of concept anddesign."

This de�nition is in common with de�nitions used by other authors. The way cooperationis described varies from e.g. involving suppliers capabilities, using suppliers information andinvolving suppliers in decision making (Echtelt et al., 2008).

There are various streams of literature within the �eld of Early Supplier Involvement.One stream focuses mainly on the right timing of involving suppliers in the new product

development process (Hartley et al., 1997; Hand�eld et al., 1999; Petersen et al., 2005; Parkeret al., 2008; Fan et al., 2000). It has long been thought that it was best to integrate the supplieras early as possible, but as Hand�eld et al. (1999) pose this also has disadvantages e.g. being"locked into" a single supplier. In other words, the design becomes manufacturable at the priceof �exibility in supplier choice. The timing of supplier involvement should be matched with theproject phase in which the decisions are made that the supplier is expected to in�uence. AsPetersen et al. (2005) put it, the best timing to involve the supplier depends on the complexityof what is outsourced and the supplier responsibility that is expected.

Another stream on which we will expand some more within our research, looks at boththe short term and long term advantages of using the suppliers knowledge during new productdevelopmentWynstra et al. (2001), Ragatz et al. (1997), Echtelt et al. (2008) and Dowlatshahi(1997).

Long term bene�ts are e.g. more e�cient collaboration with future projects and alignmentof technology road maps (Echtelt et al., 2008) and thus occur after the project, in which theactually collaboration takes place, is �nished.

24


The subjects of the short term bene�ts include (Ragatz et al., 1997; Clark, 1989; Ragatzet al., 2002; Primo and Amundson, 2002; Hartley et al., 1997):

1. Development time

2. Development cost

3. Product cost

In the next section we will go over these short time bene�ts and what is written in literatureabout them.

4.2.1 Bene�ts of ESI

ESI decreases product development time through two di�erent mechanisms.The �rst way that product development takes less time is achieved through putting activities

in parallel by having the people that will design the manufacturing process already think aboutthis during the product development (Dowlatshahi, 1997; Prasad et al., 1998).

We will now take a deeper look at the second way to shorten development time, which isthe implementation of design for assembly and manufacturing (DFMA) (Wynstra et al., 2001;Wasti and Liker, 1997; Petersen et al., 2005; Clark, 1989; Dowlatshahi, 1997). This meansthat by having the designers of the production and assembly process (which can be suppliers)present when the product design is made, their remarks can be implemented directly, preventingredesign.

A decrease in development time originates in the simpli�cation of the the design throughinvolvement of the suppliers. This simpli�cation is again rooted in the DFMA principles leadingto less parts being designed. According to Ulrich et al. (1993) the major aspects of DFMA arethe reduction of parts and the reduction of part positioning and inserting. The reduction inparts also decreases the engineering cost (Boothroyd, 1994).

Last but not least is the decrease in product cost resulting from the integration of manu-facturing and assembly knowledge into the development process. As explained, less parts aredesigned (Ulrich et al., 1993) and the parts that are designed are easier and thus cheaper toproduce because of DFMA (Wynstra et al., 2001; Wasti and Liker, 1997; Petersen et al., 2005;Clark, 1989; Dowlatshahi, 1997; Boothroyd, 1994; Petersen et al., 2003). This easier productionnot only leads to a cheaper process, but also to less quality issues and thus cost (Boothroyd,1994; Dalgleish et al., 2000; Ulrich et al., 1993).

4.2.2 Limitations of ESI

Although literature is clear about the bene�ts of early supplier involvement, the focus is verymuch on having the right information at the right time in your project. What it does not sayis how to assess the value of this information and let it in�uence the decision making processduring the new product development project.

Current literature also ignores the possible costs associated with the implementation of theremarks the suppliers have on the design and thus do not o�er a total cost bene�t overview.

This might explain how it is possible to end up with a non optimal design regarding supplychain despite an implemented early supplier involvement process as described in section 2.2.

Furthermore, early supplier involvement does not prevent that NPD decisions are madebefore the supplier is involved. And these early decisions might very well lead to unfavorablesupply chain situations.

25


4.3 Conclusion

In literature about ESI we found that a process to get input from suppliers on the design, isa well known and proven method. However, we did not �nd a solution to the problem thatavailable information from the supplier gets ignored because its impact is underestimated.

ESI also does not focus on the decisions that are made before the supplier is actually involved.Therefor we need a di�erent approach for making NPD decisions that take supply chain interestsinto account.

For decision making we turned to literature about real option theory applied to new productdevelopment projects. There we found no attention for supply chain issues, but we did �ndan approach for making decision by assessing their impact on performance and in turn on theprojects current value.

This approach will be the base of our further research but we will have to tackle the followingissues:

1. �nd a way to express supply chain performance as a value driver

2. include the in�uence of various value drivers on each other

3. make the improve impact more realistic

4. map the ASML situation onto our developed model as a case to come to an implementation

In the next chapter we will develop our own model based on what we found in literature andwhat we have de�ned as limitations that we need to solve.

26

5. Model development

This chapter will address goal 1 by proposing a conceptual model and develop a mathematicalmodel that is involved in decision making during NPD. Since all of this modeling concerns thereal options model, we will simply use the term "model" from now on. The structure of thischapter is as follows.

We start of by quickly explaining the essence of what we are trying to model, all limitationsput aside.

Secondly, the old model is revised to include supply chain issues. This is discussed on aconceptual level to show where modi�cations on the old model take place to include supplychain interests.

In the third part we discuss how the modi�cations on a conceptual level are translated to amathematical representation of the model.

Finally, we explain the limitations of the model regarding practical implementation and doa proposal how to deal with these issues, before we work out our implementation within thecontext of ASML.

5.1 The essence of the model

Before we go to the existing model followed by the improved model it is important to note whatthe essence is of what we are trying to describe with our model.

At a certain moment in time, we experience a new product development project to be in acertain state, described by f(X1, X2, . . . , Xn, t). Given that state we want to make a decisionsuch that we maximize the value of the next possible state f(X ′1, X

′2, . . . , X

′n, t+δ) were t is also

part of the state space.One can imagine this model to exist in a large table of possible states that can be reached

through a combination of chance and decision making.For our problem, we turn to a simpli�ed description of state changes according to the ap-

proach of Huchzermeier and Loch (2001) who use a lattice tree to describe the states and statetransitions. This leads to t being a �xed time interval between states that are described asproject review moments and also to a �nite amount of states that is easier to work with.

In the next section we will revisit the model of Huchzermeier and Loch (2001) and explainwhat will be re-used and what will be altered.

5.2 Model Concept

To come to a new model, we modify the old model to improve on its limitations as discussed insection 4.1.3 while exploiting its advantages. First we will explain how it is possible to de�neand add supply chain performance. Second we will show how we address the current limitationthat performance improvements do not in�uence each other. Finally we will elaborate on theimprovement option to be modeled di�erently in order to better re�ect reality.

5.2.1 Adding supply chain performance

On an abstract level both Huchzermeier and Loch (2001) and Santiago and Vakili (2005) de-�ne project value as a function of �ve parameters or value drivers while ignoring supply chainperformance.

As was stated earlier and is the core of this research, "supply chain performance" also drivesthe value of the project but is lacking in the current model.

27

CHAPTER 5. MODEL DEVELOPMENT

We investigate how supply chain performance can be added to the current model. The mainquestion here being: Is supply chain performance a sixth value driver or is it part of the alreadyde�ned performance? To answer this question we �rst take a look at how the existing valuedrivers are related to each other in the original model.

Performance

Requirements

TimeImprove

Project Cost

Payo� Project Value

Scope for change

Figure 5.1: Old model: Relations between value drivers

Figure 5.1 shows the relations investigated by Huchzermeier and Loch (2001) between theidenti�ed value drivers. The area that is our scope for change is depicted by the dashed redrectangle. The match between Requirements and Performance in�uences the Payo� that in turnin�uences the project value. The Time of the project in�uences Payo� not only directly through"time to market" e�ects but also via value driver Project Cost. This last e�ect is implementedin the model by calculating project continuation cost for every period between two reviews. Theoption to Improve is not a value driver, but does impact the model and project value just aswas meant to. Huchzermeier and Loch (2001) recognize the in�uence of the improvement actionon the Project Cost and thus de�ne "improvement cost" for every review moment.

Both Huchzermeier and Loch (2001) and Santiago and Vakili (2005) assume there is noimpact on Time as shown by the red arrow. This will not always be correct but it is anassumption that we adopt. It is mentioned here because decision makers should be aware of thislimitation when applying the model that is developed.

Now that the relations in the current model are clear, we explain what needs to be changed(depicted by the dashed rectangle) in order to add supply chain performance.

To propose a de�nition for supply chain performance we have adopted the de�nition thatwe found at ASML and is also used by other companies. ASML de�nes the performance ofa volume supplier by four parameters; Quality, Logistics, Technology and Cost, also known asQLTC. Although we did not investigate other companies in detail, we did found out that theQLTC approach is also used outside ASML at companies like e.g. VDL, DAF and Océ.

Supply chain performance is thus a four dimensional parameter consisting of Quality, Logis-tics, Technology and Cost (QLTC). Similarly to supply chain performance, market requirementsextend beyond technology and can include requirements regarding quality, cost and deliverytime1.

Analog to the performance as de�ned in the original model improvement actions can be takenthat enhance the performance. The supply chain performance indicators, Q, L, C are thus �t toextend the performance parameter T as de�ned in the existing model. Huchzermeier and Loch(2001) and Santiago and Vakili (2005) already stated that performance can be multidimensionalbut only mentioned this within the scope of technical performance. We now show that thesupply chain performance parameters can be modeled in a similar way.

Our proposal is thus to �t supply chain performance into the current model by adding the

1Cost and time here focus on the product instead of the project!

28


underlying Q, L and C parameters to the value driver performance that was currently onlyfocusing on T. Analog to that we propose to do the same for the value driver "requirement".This is illustrated in �gure 5.2 that is a close up of our scope for change from �gure 5.1.

From now on when we mention performance or requirement we refer to these multidimen-sional parameters that contain Quality, Logistics, Technology and Cost. Otherwise it will bementioned explicitly which performance or requirement is meant e.g. "Q performance", "Crequirement" and so on.

Q Performance

L Performance

T Performance

C Performance

Payo�

L Requirement

Q Requirement

T Requirement

C Requirement

Figure 5.2: Adapted relations of the performance and requirements drivers

Figure 5.2 shows the multidimensional character of performance and requirement, buildingupon both technical and non technical requirements. One level deeper it can even be arguedthat the four parameters mentioned in the picture again consist of more then one parameter(e.g. Q1, Q2, Q. . . adding up to Q performance). For our study however, we will consider onlythe parameters shown in �gure 5.2.

An important statement illustrated through the same �gure 5.2 by the red arrows, is that theunderlying dimensions of performance and requirement also can in�uence each other. Examplesof why this is true are numerous, but to name a few:

• a short delivery time might be achieved by ordering one piece at a time, driving the productcost up

• an improvement in quality might be realized through extra testing, leading to a longerdelivery time and higher product cost

• an improvement of technology might be realized by using the latest (but experimental)production processes, leading to poor (manufacturing) quality and higher cost

This is an important extension to the model as used by Huchzermeier and Loch (2001)and Santiago and Bifano (2005) as it is used for decision making. In section 5.3.2 when themathematical base of the model is discussed, I will show how this can be modeled.

In conclusion we state the following:

To add supply chain performance to the existing real options model we need to makethem part of the existing performance parameter, making it not only multidimensional,but also multi disciplinary. At the same time, it is important to keep in mind that thereare interactions between the several dimensions that underly this overall performance.

To add supply chain performance to the existing real options model we need to makethem part of the existing performance parameter, making it not only multidimensional,but also multi disciplinary. At the same time, it is important to keep in mind that thereare interactions between the several dimensions that underly this overall performance.

29


5.2.2 Improving the improve option

As was illustrated in section 4.1.3 the current model is rather static towards the impact that animprovement decision has on the performance of the project. In stead we propose to make theimpact of the actual improvement both dependent on the time and the current performance. Sothe improvement I of performance P at time t+ 1 would be like:

It+1 = f(Pt, t)

This function should work with the input of the experts working with the model, or gatheredthrough e.g. data gathering of �nished projects.

For now the main conclusion is:

We remodel the impact of an improvement decision on the performance such that itcan depend on both time and current performance.We remodel the impact of an improvement decision on the performance such that itcan depend on both time and current performance.

5.3 Mathematical model

Now that we have explained on an abstract level how the model can be improved, it is time tode�ne how this can be re�ected mathematically.

5.3.1 Adding supply chain parameters

While Huchzermeier and Loch (2001) employ a one dimensional performance parameter i(t),Santiago and Bifano (2005) represent the performance by a vectorXt which enables the de�nitionof a multi dimensional representation of performance. In our model, we combine technical andsupply chain performance to a new multidimensional performance parameter. Following thelogic of Santiago and Bifano (2005) to represent this as a vector, we de�ne performance to bethe following:

Xt =

QtLtTtCt

With Qt, Lt , Tt and Ct as the expected Quality, Logistic, Technical and Cost of goods perfor-mance at time t.

The next step is to remodel the decision to abandon, continue or improve as it also becomesmultidimensional. This is done in the next sections.

5.3.2 Modeling the decision

The decision to improve can be made for each dimension individually and thus is a 4 dimensionalvector in our case. We call this vector δt and its de�nition is given by;

δt =

δQδLδTδC

(5.1)

Equation 5.1 represents the combination of (boolean) decisions to either continue or improve onthe Q, L, T and C parameter respectively. If e.g. it is decided to improve on Q and T but not

30


on L and C, then the vector becomes δt =

[1010

]. The amount of di�erent decision combinations

adds up to 24 = 16 combinations for this four dimensional decision vector. Note that the optionto abandon leads to abandonment of the whole project and thus adds only one more decision,leading to 17 decision.

5.3.3 Modeling decision impact

The next step is to construct an improvement matrix I such that I ∗ δt represents the actualimprovement due to the decision δt. The reason for this to be a matrix is that we stated thatan improvement on one dimension, e.g. Quality has an impact on an other dimension e.g. Cost.We de�ne matrix I as follows:

I =

f(Qt, IQt−Q) f(Qt, ILt−Q) f(Qt, ITt−Q) f(Qt, ICt−Q)

f(Lt, IQt−L) f(Lt, ILt−L) f(Lt, ITt−L) f(Lt, ICt−L)

f(Tt, IQt−T ) f(Tt, ILt−T ) f(Tt, ITt−T ) f(Tt, ICt−T )

f(Ct, IQt−C) f(Ct, ILt−C) f(Ct, ITt−C) f(Ct, ICt−C)

In this matrix, f(Ct, IQt−C) is a function that represents the performance change of Cost

due to an improvement on Quality. This is a function of current Cost performance Ct and theimpact of the quality improvement action IQ on C at time t depicted by IQt−C .

The equations that are marked green are the most forward equations that determine theimpact of an improvement action of one dimension on itself, e.g. the e�ect of a Quality improve-ment on Quality.

5.3.4 Modeling the performance

With matrix I de�ned we can write the equation for the performance Xt at t = t+1 as follows:

Xt+1 = Xt + I ∗ δt + ωt (5.2)

With ωt as a vector representing the change in performance due to chance. In the case of the

decision to continue on all dimensions: δt =

[0000

]the change in performance is solely determined

by ωt.

5.3.5 Modeling the value de�nition

Now that we have de�ned what the performance is we can start to de�ne what the value is fora certain performance state. Recall that we need to �nd the decision that maximizes this value.

In our case of a multidimensional performance parameter with a decision vector δt we de-�ne the total cost for all improvement decisions as a horizontal vector that together with thedecision vector forms a scalar product that adds up all improvement cost. The de�nition of thisimprovement cost vector ICt is:

ICt =[ICQt ICLt ICTt ICCt

]With ICQt, ICLt, ICTt and ICCt as the Improvement Cost at time = t for Q, L, T and Crespectively.

We can now de�ne the dynamic programming equation that captures the trade o� as follows:

Vt(x) = maxδt

{−ICt ∗ δt +

1

1 + rE [Vt+1 (Xt+1 (x, δt, I, ωt))]

}(5.3)

31


Equation 5.3 can be maximized by choosing the optimal improve or continue strategy de-picted by δt. This maximization thus gives us the optimal decision for every point in the latticetree and should be means of backward recursion give us the best decision at the start of the tree.

5.4 Limitations for implementation

The improvement matrix I as introduced in section 5.3.3 shows formulas for the improvementimpact of all dimensions on all dimension. If e.g. it is decided to execute an improvement forall dimension, the formula for the Quality performance on t = t+ 1 is de�ned by:

Qt+1 = Qt + f(Qt, IQt−Q) + f(Qt, ILt−Q) + f(Qt, ITt−Q) + f(Qt, ICt−Q) + ωQt (5.4)

with ωQt as the Quality component of the performance change due to chance.Although applying the model in this way provides an answer that is theoretically more

correct, it is preconditioned by a highly predictable in�uence of the parameters on each other.In practice we expect that it will depend on the actual improvement action that is decided upon,what the impact on the other parameters is. Although this might be known for the �rst decisionto make, it will be harder to predict for future states.

Another practical boundary that we expect is that the computational complexity increasesdramatically when the interactions between the parameters need to be considered.

To develop an application as set in goal 1 that is an implementation of the model thatwe developed in this chapter, we propose to use the following impact de�nitions for actualcalculations:

Qt+1 = Qt + f(Qt, IQt−Q) + ωQt

Lt+1 = Lt + f(Lt, ILt−L) + ωLt

Tt+1 = Tt + f(Tt, ITt−T ) + ωTt

Ct+1 = Ct + f(Ct, ICt−C) + ωCt

5.5 Conclusion

As a �rst answer to our research question we found the following:

To improve the assessment of a supply chain issue and make better NPD decisions, wecan turn to real option theory as applied to dealing with risk during NPD. We can addsupply chain performance to this model to use it to make New Product Developmentdecisions that ultimately prevent unfavorable supply chain situations.

To improve the assessment of a supply chain issue and make better NPD decisions, wecan turn to real option theory as applied to dealing with risk during NPD. We can addsupply chain performance to this model to use it to make New Product Developmentdecisions that ultimately prevent unfavorable supply chain situations.

The model development as described in this chapter, answers to goal 1 and is a more detailedanswer to our research question.

However, we de�ned a second goal to develop an implementation of our model.In chapter 7 we will discuss an actual implementation of the model in a software application

building upon the recommendations of section 5.4. But �rst we will investigate in chapter 6how we can de�ne the ASML case in terms of our developed model as a preparation for ourapplication development.

32

6. De�ning Supply Chain Performance

To develop an implementation of our real option model that supports decision making duringNPD and includes supply chain issues, we need to get a deeper understanding of how supplychain performance can be de�ned.

We have to understand what parameters are important to supply chain performance so thatwe can measure the situation. In particular it is important to �nd a �nancial representation ofsupply chain performance in order to be able to use our model as described in chapter 5.

The core goal of this chapter thus is to deepen the understanding of the problem in termsof the model that we have developed and operationalize supply chain performance variables.This way we translate the concept of supply chain issues to terms that can be used in animplementation.

To come to a de�nition of supply chain performance, we use ASML as a test case andinterview ASML employees who are involved in supply chain management. The informationfrom this chapter is the outcome of those interviews.

6.1 Supply chain performance indicators

We already introduced the way that ASML and some other companies de�ne the performance ofa supplier on a conceptual level when we developed our model using the Quality, Logistics, Tech-nology and Cost parameters. We thus already know that we need to deepen our understandingof this QLTC as it is abbreviated.

At ASML, the procurement department is overall responsible for the QLTC performanceof the suppliers but other departments are involved. For a top 'x' list of suppliers selected bythe procurement department there is pro active management on the QLTC performance of thatsupplier through a Supplier Account Team (SAT).

The members of the SAT (headed by the Procurement Account Manager) that guard theQLTC performance are representatives of ASML departments as well as supplier representatives.The ASML departments that are represented manage the individual performances at ASMLregarding quality, logistics, technique and cost. To track the actual state of the supplier andshow the preferred state, a supplier pro�le is made. From that overview actions are de�ned andexecuted together with the supplier to close the gap between what is called the wish and actual

performance.The supplier pro�le is normally used to assess and act on an existing supplier performance

but we think that it also provides a clear approach to assess the future situation during newproduct development.

All in all, we see that supply chain performance is build up as shown in �gure 6.1.

Supplier pro�le

Q performance

Q1 Q2 Q..

L performance

L1 L2 L..

T performance

T1 T2 T..

C performance

C1 C2 C..

Figure 6.1: Construction of Supply Chain Performance

The overall supply chain performance is represented by the supplier pro�le and one level

33

CHAPTER 6. DEFINING SUPPLY CHAIN PERFORMANCE

deeper we �nd the QLTC performance. In practice the Q, L, T, and C performances are alsomulti dimensional as is represented by the next level with Q1, Q2 and so on.

We will now go over the four performance parameters Q,L,T and C to explain them andevaluate how they can be used in a decision model.

6.1.1 Quality

Quality performance is measured by various parameters within the supplier pro�le as was illus-trated by �gure 6.1. Some parameters can di�er from supplier to supplier, due to the big rangeof suppliers ASML deals with. This includes standard parts suppliers, complex parts suppliers,module suppliers, OEM suppliers and all kinds of suppliers in between.

Regarding quality, the �rst and most important parameter within the pro�le is the amount ofdefective parts per amount of delivered parts, also called MQP (Material Quality Performance).In this context a defective part is de�ned as a part that does not comply with the design. TheMQP is reported to the supplier on a monthly base and is tracked and discussed within thesupplier account team meetings.

The other parameters also include organizational aspects of the supplier that are importantfor the quality performance but less interesting in this context of evaluating a design and makingdecisions on the design.

As with all parameters in the supplier pro�le, MQP performance is rated on an 'A' to 'E'scale were 'A' represents the best performance and 'E' the worst performance. The actual valuesof those ratings are determined within the supplier account team. Table 6.1 shows an imaginaryexample of such a rating for MQP.

Rating Target MeaningA < 0.1% Percentage wrong parts per amount of deliveriesB < 0.2% idemC < 0.6% idemD < 1% idemE > 1% idem

Table 6.1: Example MQP rating

The total cost of a bad MQP performance is very hard to measure. When asked about theimpact of parts that do not comply with the design, interviewees mentioned following possibleimpacts:

• Human safety issue

• Production delay in ASML factory

• Cost increase of product (when design is too di�cult)

• Downtime at ASML customer (serious �nancial impact)

• Damage of other parts

• Cost of error handling hours to e.g. analyze, repair and return.

It was also mentioned that in practice it is often hard to determine wether the defect was causedby the supplier or by ASML. This means that there will also be cost for part replacements thatwere actually caused by supplier induced defects. Parts with defects caused by the supplier, arerepaired or replaced at the cost of the supplier. However, since the design of the parts is oftenat the limits of manufacturability, suppliers might be motivated to increase the product priceon this particular or a similar future product.

34


Despite of the di�culties to determine the actual cost impact of a defective part it is necessaryto de�ne a cost impact to be able to develop an implementation of our model. On the one hand,parts are often replaced at the cost of the supplier. On the other hand, a lot of cost resultingfrom the defect is not payed for by the supplier.

To come to a de�nition for the �nancial impact of a non conforming part, we take the productcost of the part that was deemed defective as the base of the actual impact. Since (as we showedin chapter 5) the decision making process involves a �xed investment to prevent recurring qualitycost, there are two other factors that have to be taken into account. First, it is important toknow how many parts will be produced during a certain amount of time, e.g. a year. Second,we must know the return of investment, thus how many years it will take before the investmentcost brake even with the bene�ts.

For the new product development project to be able to have a positive e�ect on the qualitycost, there must be a target de�ned. Then it is the di�erence between the target and the actualquality performance that determines how well the project is doing. Without this target, theproject would always have a bad performance.

The formula to determine the quality performance PQ can now be written as:

PQ = (Yt − Ye) ∗ Cog ∗ Py ∗ PbT (6.1)

With Yt and Ye as the yield target and the yield expected respectively and Cog as the costof the product. Py stands for the produced amount of units per year and PbT (Payback Time)for the amount of years that we want the investment to pay back.

With the quality performance expressed �nancially, we now turn to logistics to do the same.

6.1.2 Logistics

Like quality, logistic performance at ASML is expressed in more then one parameter within thesupplier pro�le. An example of this is a parameter called �exibility that expresses the abilityto both increase and decrease production volume within a de�ned amount of time. The goalof this target is to ensure that the production capacity of a supplier complies with the currentdemand but is �exible enough to change with future demands.

To calculate the impact of design on logistics, a parameter is needed that can be heavilyin�uenced by the design. Ideally this parameter is also a target for the new product developmentproject.

A very important logistic performance parameter is called Cycle Time or CT. Cycle Time isde�ned as the time it takes from order to delivery, without having stock of semi �nished productsor material. Amongst other reasons, it is important from a �nancial point of view that the timeto manufacture a product is as short as possible. The longer it takes to manufacture a part, thelonger its cost will be on stock and thus �nances are frozen to other usages. Lowering the WIPor work in process is a measure that can seriously cut costs and commitments within the supplychain.

A second factor that impacts �nances like CT, is the timing of activities that add most valueto the product. That is to say that in an ideal situation the activities that add the most valueshould be planned as late as possible to prevent having that value on stock for a long time.

Both factors mentioned are combined in a value curve that describes how the value of theproduct changes over time. Figure 6.2 illustrates this by showing an example of a value curve.The area below the line multiplied with the production amount per day represents the cost thatis manifest within the supply chain.

35


10

20

30

0 20 40Time [days]

Cost of Goods [ke]

Value curve

Figure 6.2: Value Curve of a part

Given a �xed cost of goods, there are two ways to decrease the area and thus the costs:

1. Decrease Cycle Time

2. Shift most value adding activities to the right

To measure the logistic performance we have to know the area beneath the graph. More preciselyand analogue to the quality performance, we have to know the di�erence between the area ofthe target logistic performance and the actual or expected logistic performance.

The logistic performance PL is expressed in formula 6.2, with Rop as the rate representingboth interest when money would not be "stuck" in the WIP and inventory risk.

PL =Rop365

(∫ t=Cte

t=0Ve(t)dt−

∫ t=Ctt

t=0Vt(t)dt

)∗ Py ∗ PbT (6.2)

PbT and Py represent the Payback time and production per year respectively, analogue to thequality performance function. Cte and Ctt represent the cycle time expected and the cycle timetarget in days (t). Finally Ve and Vt are the value functions that describe the increase in valueof the product over time during production, for the expected cycle time and the targeted cycletime respectively.

6.1.3 Technique

If we look at how the supplier pro�le is used at ASML, technique is the parameter that standsa side from the other three parameters. Since some suppliers have development facilities andknowledge about subsystems of the ASML equipment, it is important for the supplier accountteam (SAT) to assess such a supplier on its performance regarding the technique parameter.

Within the speci�c research that this is, the technique parameter is already accounted forwithin literature and does not address the speci�c supply chain issues that we want to prevent.

Huchzermeier and Loch (2001) use the gap between market requirement and (technical)performance to value the technical performance. That is highly comparable to the target versusexpected performance approach that we use in the various performance parameters. However,they do not expand on formalizing this value but rather o�er a general graph about the relationbetween the "performance - requirements" gap and the payo�.

In this study, we do not expand on the available knowledge in literature about expressing themonetary value of the technical performance parameter but proceed with the next parameterCost of Goods in the following section.

36


6.1.4 Cost of Goods

This last parameter "Cost of Goods" is very straightforward to measure since it already involvesa monetary unit of measure. The only thing that needs to be done is to compare the actualCost of Goods with the target that has been set, analogue to the situation with both qualityand logistic performance.

This leads to formula 6.3 expressing the CoG performance PC with Py representing theamount of units produced every year and PbT the amount of years the investment should bepaid back.

PC = (CoGexpected − CoGtarget) ∗ Py ∗ PbT (6.3)

6.2 Conclusion

Earlier we found that the supply chain performance within ASML is measured on a four di-mensional scale with the dimensions being; Quality, Logistics, Technology and Costs or QLTC.The dimension "Technology" used within the supply chain management of ASML, is alreadyaccounted four in current real options literature applied to new product development projects.

The QLTC approach is not only used by ASML but also by e.g. VDL, DAF and Océ. Sincewe did not investigate those companies like we did ASML we will only state that the QLTCapproach is likely to be suited for the measurement of supply chain performance outside ASML.

We found a way to valuate the Q, L and C performance based on information from theASML way of working.

With these �nancial de�nitions of the supply chain performance parameters, the next chapterwill develop an implementation of our model to help take new product development decisionsas described in goal 2 on page 15.

37

7. Application and testing

With this chapter we will describe an implementation of our mathematical model using thede�nitions for supply chain performance that we developed in chapter 6. Besides developing animplementation and thereby addressing goal 2 we also use our implementation to run tests withthe model.

The structure of this chapter is as follows.First we will explain how the software application was put together. We will de�ne the scope

of our software, show the user input that is needed and explain the limitations that our speci�cimplementation has.

Second we will explore a basic test case to see how the application works and investigate itsadded value. This test case will also be used to change inputs and look at the sensitivity of themodel.

Finally we will discuss what the limitations of the software are and what additional activitiescould be undertaken to come from this prototype software to an actual implementation of anNPD decision supporting system. We will also propose a di�erent approach on the implemen-tation of our model that deals with most limitations of our implementation as well.

7.1 Software Implementation of Model

7.1.1 Scope

As part of this research we develop a software application to put the calculations from the modelto practice and run cases. This has two advantages.

First building an application based on the model forces us to take a critical look at the modelfrom a di�erent angle. This new look at the model challenges its applicability for practitioners.

Second, by having software based on the model, we can run tests to look at the behaviorof the model which would be far too time consuming to do by hand because of the numerouscalculations that have to be made.

To come to such an application we choose to develop software using the programming lan-guage Java. The choice for using Java is based on its high level programming ability (Java is anobject oriented language) and the partial familiarity of the author with Java.

Programming in a lower level language like C or C++ would probably have led to fastercalculations but would have been far more work. Another advantage of Java is that it resultsin a programm that can run on various operating systems like Linux, Windows and Apple OSwithout the need for recompiling the source code.

The following requirements were de�ned for the software to be developed. It should:

1. Have a graphical user interface

2. Take user input for the project and review variables

3. Construct a graphical representation of the decision tree

4. Calculate and show the decisions leading to highest value

5. Calculate and show the value for the optimal decision for every state in the decision tree

6. Enable calculations for 1 dimension; Quality

38

CHAPTER 7. APPLICATION AND TESTING

Requirement 6 is de�ned to limit the programming e�orts while at the same time maintainingthe possibility to study the behavior of the model. The reason that we can still study thebehavior while only modeling one supply chain performance dimension is that we adopt therecommendation not to incorporate the in�uence of the various dimensions on each other (seealso section 5.4 for explanation). The choice of value driver Q is arbitrary since we also studiedhow to de�ne the performance measures for L and C.

Section 7.4 will expand on how the other value drivers might be implemented in software.

7.1.2 User input

Project �gures

Figure 7.1 shows the data that needs to be entered by the user to have the basic informationneeded to create a project. We will walk through those values to explain what their usage is.

In the text �eld "Reviews [#]" the user can enter the amount of reviews that the project willhave. These review moments represent the t from our model and for every t all possible statesare calculated.

Figure 7.1: User input on a project level

The value that needs to be �lled in for text �eld "Discount rate" represents a discount thatneeds to be calculated for the time between two review moments. This discount rate is neededto calculate the net present value of the project at a certain state. For more background on theusage of NPV within real option theory we refer to the work of Dixit and Pindyck (1994).

Since we decided to develop an implementation based on the supply chain performanceparameter "Quality", the text �elds "Worst expected", "Most Likely" and "Best Expected" areto be �lled with values for the expected yield of the product. E.g. entering a value of 0.8 wouldmean that 20% of the production is scrapped. The reason that there are three values is ourimplementation to get a (triangular) distribution of outcomes to which the decision tree willlead. In project management a similar heuristics is used. There it is e.g. applied as an approachto get a less biased estimation of the duration of an activity, compared to a direct estimation(Meredith and Mantel, 2002).

The value for "Best possible" is also a yield value, needed for our implementation of theimprovement impact. We de�ne this best possible value as either the best possible estimate oran actual boundary to the value. In our case of yield, the maximum possible value is 100% or 1.

At the right end of �gure 7.1, there are three input �elds to �ll in �gures that are requiredto calculate actual values that belong to a certain performance. These are "Cost of Goods"representing the cost of the product or semi �nished product that is the subject of the project,"Products / year [#]" representing the amount of goods produced per year, and the "Paybackperiod [yr]" that represents the amount of years that an investment should be payed back.

Finally we have one variable left, being the target value for the performance that we willexpand a little more on in the next section.

Target performance

The target performance value is a speci�c implementation of the model that is a very usablesimpli�cation within ASML context.

39


ASML delivers complex machines that consist of hundred thousands of parts and variousdi�erent types of technology. To deal with the development of such big projects, they are dividedinto sub projects with each their own project leader. Figure 7.2 shows what the structure ofsuch a project can look like.

Machine A

Module 1 Module 2 Infrastructure X Technology Y ...

Figure 7.2: Project hierarchy

As �gure 7.2 shows, a project for "Machine A" is divided into smaller "sub projects" thattake care of various subjects of the total project. These sub projects can develop modules of thesystem, but can also develop things like an infrastructure (e.g. electronic cabling) or a certaintechnology speci�c for the machine (e.g. clean vacuum environment).

Our implementation aims at such a sub project.To guard the performance of the total machine A, all sub projects have speci�cations about

their interfaces with other projects and their performance. Of course their performance addedup still has to comply with market requirements, but these market requirements are spreadamong the various sub projects.

The performance speci�cation of a sub project is not a distribution of outcomes like marketrequirements but is a �xed target. This simpli�es our current implementation of the model.

Furthermore, the decision to quit the project can never be a decision of a sub project atASML but can only be the decision of the total project that is called "Machine A" in �gure 7.2.We thus need to be able in our software to disable the option to abandon the project.

Summarized we state the following.

Our scope is a sub project that delivers a performance to a larger project. In theimplementation of our model, (sub) project speci�cation is used similar to marketrequirement but is a �xed target instead of a distribution.It has to be possible to disable the option to abandon because sub projects at ASMLare normally not allowed to decide for the whole project to quit.

Our scope is a sub project that delivers a performance to a larger project. In theimplementation of our model, (sub) project speci�cation is used similar to marketrequirement but is a �xed target instead of a distribution.It has to be possible to disable the option to abandon because sub projects at ASMLare normally not allowed to decide for the whole project to quit.

Review �gures

Figure 7.3 shows our implementation of making parameters time dependent. This is done byenabling the user to enter these parameters per review moment like e.g. the cost to continue.On the �rst row we can see that this project has 5 review moments, the �rst being the start ofthe project.

For every review moment there is some information that needs to �ll in that we will nowtake a look at.

The "Cost to continue" represents the normal development cost during the period betweentwo review moments.

The "Cost to Improve" represents the estimated cost in order to execute an improvement atthe speci�c review moment. By making both the continue and improve cost time dependent, itis possible to deal with the e�ect that development cost might very well increase over time asalso described by Huchzermeier and Loch (2001).

40


Figure 7.3: User input on the review parameters

The improvement percentage is our implementation of making the improvement impact de-pendent on both time and current performance. We de�ne this �gure as follows:

Improvement percentage is the percentage of the gap between currently expected

performance and Best Possible Performance that an improvement action can close.

The time dependency of the improvement impact was easily implemented by �lling it infor every review moment. However, by de�ning the improvement impact to partly close thegap between current and best possible performance, we were able to also make it dependent oncurrent performance. For more background on the calculations for this improvement impact andthe use of "Best possible performance", we refer to appendix C.

"Nr of Next possible states" is an entry that lets the user in�uence the spread of the perfor-mance that a certain review moment might have. In the beginning of a project it is likely thatthe number of possible outcomes is larger then towards the end of the project when a lot moreinformation is available.

Finally, there is a "Chance" �eld for the number of possible next states that have beende�ned. Figure 7.3 shows an example where at the start of the project, there are three possiblenext states with 30%, 40% and 30% chance of occurrence respectively.

By de�ning this number of next possible states and enabling to enter the chance for everystate, the triangular distribution of performance outcomes as explained in the previous sectionabout the project parameters can be shaped more to reality. However, if the data to do so is notavailable it can be ignored by entering two states with a 50% chance to every review moment.

Most of this implementation is in line with the current models, but our main contribution isthe following.

By de�ning the impact of improvement to be a percentage of the gap between currentand maximum performance, we are able to make the improvement impact dependentof the current performance. Furthermore, by entering the improvement percentage perreview moment, we are also able to make the improvement impact time dependent.

By de�ning the impact of improvement to be a percentage of the gap between currentand maximum performance, we are able to make the improvement impact dependentof the current performance. Furthermore, by entering the improvement percentage perreview moment, we are also able to make the improvement impact time dependent.

7.2 Limitations of the implementation

Although we have tried to keep the implementation close to the actual situation, there are someassumptions and thus limitations to this implementation that we will represent in this section.

The �rst limitation is inherited from our mathematical model and is the same as in themodel from Santiago and Bifano (2005) that our model was build upon. That limitation is thatin practice it might take additional project time to execute an improvement action. Executing

41


the improvement in parallel might not always be possible due to restraints in developmentcapacity or due to technical limitations.

Second, although in chapter 5 we included the in�uence that the various dimensions ofperformance have on each other, in our software implementation this was not implemented dueto two reasons:

1. Computational complexity (too much computer time needed)

2. Inability to capture the mutual in�uence of the parameters with a formula for futurereviews

The second reason comes from the fact that both magnitude as well as the direction of thein�uence of e.g. an improvement on Quality on the performance of Logistics is not generalizablenor predictable.

With these known limitations, we will now conduct some tests with a sample case.

7.3 Testing

7.3.1 De�ning a test project

To test our model, we have chosen to simulate a project that is non existing but is constructedwith data that is realistic for an ASML (sub)project. The data as shown in table 7.1 was usedas input for the overall project. The simulation project consists of a project with 4 reviews,

Parameter Value Parameter ValueReviews 4 Worst Expected 75%

Discount Rate 0.02 Most Likely 90%Cost of Goods e25000 Best Expected 95%

Products / Year 120 Best Possible 100%Payback Period 2 Target 99%

Table 7.1: Overall project data - simulation

simulating a one year project with quarterly reviews. The discount rate was set at 2% perreview period which means in our case roughly 8% over a whole year.

The product that is developed in our simulation has an (estimated) cost price of e25k, andis produced 120 times a year. The common target for investments for this project is that theyneed to have a payback period of two years (from start volume production!).

Regarding the estimated yield performance, the table shows that the expert estimate is 75%,80% and 95% going from worst to best estimate. The best possible performance is set to themaximum feasible value of 100% which means no errors that lead to scrap of products.Finally the target for the yield performance was set to a 99% yield.

The next step is to �ll the data for all 4 reviews of the project which are depicted in table7.2.

In our test case abandonment is not an option. Therefor it does not matter what �gure is�lled in for the cost to continue. To prevent confusion we have entered e0 as continuation cost.

The cost to improve was based on adding one specialist to the project for roughly e1k aday at the beginning of the project. We also modeled the fact that there is more work involvedin improving a design closer to the end of the project, by adding the need for one additionalspecialist for every next review moment. So at t = 0 the project needs one additional specialistto improve, at t = 1 the project needs two specialists and so on. In practice, this improvementcost will also often involve obsolescence of (prototype) materials.

The improvement percentage was modeled to decrease over time. This is intuitive, especiallysince we made the assumption that an improvement action does not delay the project. Not

42


Review t= 0 1 2 3Cost to Continue 0 0 0 0Cost to Improve e60k e120k e180k e240kImprovement % 50% 40% 25% 5%Next states [#] 4 3 2 2

Chances 20% 30% 50% 50%30% 40% 50% 50%30% 30%20%

Table 7.2: Review data - simulation

delaying the project will mean that e.g. no tests can be redone and the focus of change becomesmore and more on details instead of fundamental design choices. We chose to let this decline ofimprovement impact be stronger than linear over time. The exact �gures 50%, 40%, 25% and5% were estimates that the experts had no real experience with. It will thus be important totest the models sensitivity to these values later on.

7.3.2 Running the test project

In �gure 7.4 the result is shown from running the test project with the previously de�ned values.We will quickly describe how the output of the programm can be read.

Start node

Decisions at t=2

Expected performanceand current value

Project resultsperformance and value

Figure 7.4: Software output of the test project

When the "Calculate and draw Tree" button is hit, a decision tree is drawn consisting ofblue and green nodes that are connected with blue lines. Blue nodes represent the decision tocontinue, green nodes represent the decision to improve. Red nodes indicate the decision toabort but they are not shown as we decided upon a project where abortion is not an option.

43


Decision Improve

Continueat t = 1

Figure 7.5: Decision tree test project

The green node on the outer left side (the start of the tree) represents the decision that isto be taken at the start of the project. In this case the decision is to improve, depicted by thecolor green and the letter "I" in the node. From this node, only the paths are drawn that arethe result of this decision and a "chance" factor. Since we de�ned that from the �rst review wecan have 4 di�erent outcomes, there are 4 paths drawn.

A node in the output can be clicked, resulting in a yellow note that pops up and shows whatthe current expected performance is in that node and what the value of that node is.

Furthermore we can see in �gure 7.4 that nodes that are aligned vertically represent statesat the same time. As an example, a line is drawn around all decisions belonging to a review att = 2.

Finally we see at the right the end of the tree black nodes represent all possible end statesof the project, belonging to the di�erent possible paths. In the nodes, the performance and thevalue of the speci�c node is shown.

7.3.3 Discussion of results

Figure 7.5 focuses in on the tree that was created by our software, leaving out the rest of thescreenshot. Looking to this result, we want to note the following items:

• Almost the complete lower half of the tree is missing. The lowest end performance is 92%while the worst estimated performance was 75% and the most likely performance is 90%

• Only in the beginning of the project (t = 0 and t = 1) and with the worst performanceexpectations, an improvement decision is chosen. This is shown by the green ellipse

• The decision of the node labeled "Continue at t = 1" was not obvious. An expectedperformance of 90% early in the project with a large spread of next possible states and atarget of 99% might very well have led to a di�erent decision without the model

• The decision to invest in an improvement already at t = 0 was not obvious. At ASML itis often decided to delay such an improvement decision in order to gain more data.

44


The �rst item is not very surprising given the analogy with �nancial real options whereinvestments are also based on harvesting the upward potential and discarding the downwardspotential, leaving only the upper parts of the distribution (Dixit and Pindyck, 1994).

The second item is also no big surprise since the cost of improvement in the beginning isrelatively low and the impact relatively high compared to later on during the project.

Finally, the last two notions show the added value of the model because we see decisionsthat are not obvious without using the model.

Decision Improve

Figure 7.6: Decision tree according to old model

A second test is done to investigate wether our results also bring new insights compared toresults that would be based on the existing models. We do this through a simulation of thesame project, but with the implementation of the improvement impact according to the modelof Huchzermeier and Loch (2001). Figure 7.6 shows the result of this test.

The �rst noticeable di�erence is that this tree is a nice lattice tree that can live in an integerspace. That is because of the implementation of the improve impact that shifts the performanceexactly 1 unit up.

We also see that the lower part of the tree is lower then in our own model resulting from thefact that the impact of the improvement action on t = 0 in our model has more impact.

A �nal di�erence are the two nodes where the optimal decision is to improve, depicted bythe green ellipse and label "Decision Improve". Analog to our model, the �rst decision of theproject is to improve. But a di�erence is that in our model we do not improve at the end ofthe project like in the model with a �xed improvement impact, analogue to Huchzermeier andLoch (2001) and Santiago and Bifano (2005). We can explain this di�erence by the fact that inour model the impact of the improvement declines very much at the end of the project, while itstays the same throughout the project in the model of Huchzermeier and Loch (2001) Finally

Figure 7.7: Decision tree according to old model, with abandon option

45


we have run the same project using the logic from the model of Huchzermeier and Loch (2001)but now also including the abandon option. This is depicted in �gure 7.7.

Since there are no end results with a positive outcome, we see that at t = 3 all decisions aretwo abandon the project. The only reason that this does not happen earlier is that we used acontinuation cost of 0ein the de�nition of our simulated project.

In the following section we proceed to test our model with some extreme values.

7.3.4 Sensitivity analysis

On the parameters that are hard to predict, we decided to enter extreme data and look at thebehavior of the model. We will describe which test have been done and how the behavior waswith those tests. The actual graphs of the tests can be found in appendix D.

For the tests we used the same data as from our previous test project, but made alterationson some parameters as described in the following list of tests..

Test 1: All improvement cost e100

Test 2: All Improvement cost e800k

Test 3: All improvement % set to 80%

Test 4: All improvement % set to 5%

Test 5: Nr of next possible states all 2 - 50%, 50%

Test 6: Nr of next possible states all 5 - 10% 20%, 40%, 20%, 10%

Test 7: All improvement cost e120k and all improvement % set to 30%

We will now go over every test to describe what we found.

All improvement cost e100

With all improvement cost set to a very small investment, we would expect that all decisionsare transformed to "Improve". This is exactly what happened with an exception of two nodesin the tree that already had the maximum possible performance and thus would not gain froman improvement.

All Improvement cost e800k

With the improvement cost set to a very high amount we expect that almost all or all decisionwould shift to continue and that no improvement decision would be taken. This is indeed thecase and results into a recombining lattice tree with all continue decisions.

All improvement % set to 80%

The next test was to see what the result was of setting an improvement percentage (impact ofimprovement) to a high and constant value throughout the project. The resulting tree showsthat if the impact of the improvement decision stays the same throughout the project that moretowards the end of the project an improvement decision is taken. In our particular test almostall decisions at the last review is to improve. This leads to such high values of the nodes in thelast review, that all previous decisions are to continue, sparing the cost to improve even thoughimprovement still costs more money at the end of the project.

46


All improvement % set to 5%

Similar to the previous test we set the improvement percentage constant but now to a constantlow value. Our software behaves predictable because it shows that all decisions are set tocontinue. No improvement decision is advised and again we have a nice blue lattice tree.

Nr of next possible states all 2 - 50%, 50%

To investigate the in�uence of the spread of performances, we set the "Nr of next possible states"to 2 and their chances both to 50%. Although there are less states then in our original project,the tree is rather similar to our project. In the same areas the improvement decision is optimal.

Nr of next possible states all 5 - 10% 20%, 40%, 20%, 10%

A follow up on the previous test is setting the "Nr of next possible states" to 5 for every reviewmoment with a symmetrical distribution of chances that is; 10% 20%, 40%, 20%, 10%. This ofcourse complicates the tree very much because now there are 781 states but it generally showsthe same areas where an improvement decision should be made.

All improvement cost e120k and all improvement % set to 30%

This last test case is interesting in a special way since it can help to postpone investment inimprovement. Prerequisites for this case are that the improvement costs are always the same,disregarding when the improvement takes place and the impact of the improvement is always thesame. Here we see that we do not have an improvement decision at the beginning but we delaythe investment until expected performance decreases too much. The tree very clearly shows thatif during the project a decline in expected performance takes place, the optimal decision is toimprove.

7.4 Findings and limitations

From the tests with our model we can conclude that we were able to translate our mathematicalmodel into a practical implementation of which we can say the following.

Our software application• provides new insights compared to current "gut feeling" at ASML

• provides new insights compared to a decision made using the existing logic fromHuchzermeier and Loch (2001) and Santiago and Bifano (2005).

• shows intuitively correct behavior when exposed to extreme values

Our software application

• provides new insights compared to current "gut feeling" at ASML

• provides new insights compared to a decision made using the existing logic fromHuchzermeier and Loch (2001) and Santiago and Bifano (2005).

• shows intuitively correct behavior when exposed to extreme values

We do also consider four speci�c limitations of our software that we list as follows. Oursoftware application

1. is only "proof of concept" that focuses on 1 parameter only

2. does not implement the in�uence of parameters on each other

3. is sensitive to data in a predictable way, but this concerns data that is hard to predict

4. has a �nite number of states per review and will thus always deviate from reality

47


In order to deal with the limitations we would like to formulate some recommendations forpractitioners that want to implement a solution like we have developed and described.

7.5 Recommendations for implementation

7.5.1 Dealing with limitation 1

First we deal with limitation 1, the fact that our software is only "proof of concept" that focuseson 1 parameter only. In order to use this software for real decision making, it would have to beextended with the other parameters L, T and C to represent all issues that are also addressedin our mathematical model. We have anticipated upon this within our software regarding thecalculation of values. The programm can be expanded instead of altered to incorporate valuecalculation for other parameters like L, T and C as discussed in chapter 6.

Besides adding L, T and C according to the de�nition we found at ASML, it is also possibleto come up with di�erent value functions for these parameters or add additional value driversto the model.

The source code of the software is included in appendix E and has been commented through-out the code for future developers.


The second limitation, "in�uence of parameters on each other is not implemented" was alreadyforeseen in section 5.4 and is based on three reasons. First it seems impossible for practitionersto estimate the in�uence that improving parameter "A" has on parameter "B", especially forfuture states. Second if that in�uence was accounted for, it would increase the calculation powersubstantially, leading to a possibly impractical computer performance. Finally, there was thepractical issue that the scope and timing of this research did no allow for the implementation ofall parameters. We do however have three recommendations how to deal with this issue.

1. Start with the Cost of Goods parameter since Cost of Goods is input to calculate others.

2. Iterate the decisions for the various parameters if new insights make previous assumptionsobsolete

3. Use reason to incorporate the in�uence of parameters on each other. E.g. if the optimaldecision for Q is to improve and the impact of that on L is known, change the expectedperformance of L accordingly. And again, iterate on the outcome.

Our third recommendation is very important and was anticipated upon in our research. Recallthat we speci�cally strived to express all performances in a monetary value so that it is possibleto compare them with each other. The total performance is always the sum of the individualperformances and this can be used to make iterations to come to the best overall performance.


The third limitation that our software "is sensitive to data in a predictable way, but this concernsdata that is hard to predict" seems easy to address theoretically but will prove to be harderin practice. Since the model is sensitive to the improvement percentages that are used as wellas the improvement cost (which is what we wanted) it is important to have good estimates onthese parameters. We however did get the feedback from experts at ASML that these �guresare hard to predict. To deal with this we propose two things.

First our software can be used to �ll in several di�erent improvement impact and improve-ment cost functions so that the outcome can be compared. In those cases were the di�erent

48


functions lead to the same decision at t = 0, a decision can be made. Others situations are stilltough.

The second way to deal with this issue is data gathering. By using the software for projectsand following up on the actual improvement costs that are spend and the actual improvementsthat are realized, heuristics can be developed that are usable for future projects.


The �nal limitation is a little easier to address because even though we do not describe everypossible state with the tree, we do accept this as an approach of the real situation at t = 0. Wethus propose to recreate the decision tree for every review moment, based on the informationthat is available at that moment. Over time, the amount of future reviews will decline and thetree will become shorter. By saving the trees for all reviews, it is possible to collect the real paththat has been "walked" at the end of the project and use it for future projects as we proposedpreviously.

7.5.5 A di�erent approach for implementation

Finally we want to discuss a di�erent approach for the implementation of our model as developedin chapter 5. The reason for this is that this approach potentially can deal with almost alllimitations that were mentioned. Unfortunately we were not able to expand on this within thecurrent research.

The driver of this approach is that in practice it will be di�cult to predict what will happenin future (intermediate) states of the project.

It will be less di�cult for people to predict what will be the result of a decision that is takenright now and what the range of possible end states of the project are. If we would implementour model according to this, only three moments in time remain: now, the next review momentand the end of the project. This is depicted in �gure 7.8

I

I

I

I

C

Value 1

Value 2

Value 3

Value 4

Value 5

Value 6

Value 7

Value 8

Value 9

Value 10

Value 11

Value 12

t t+ δt

Figure 7.8: Di�erent approach for implementation

At the start of the tree we see a decision that leads to four next possible states at lets saythe next review moment after time interval t After that the tree immediately jumps with time

49


interval t + δt to all possible end states of the project. With this approach there are far lessstates to take into account which signi�cantly decreases the computational power that is needed.

So not only have we accomplished a way to prevent "false accuracy" from estimating inter-mediate states, we also have gained computational power.

With the computations getting easier, there is room to implement the in�uence that thevarious parameters have on eachother as we de�ned in section 5.3.3. In this case a node in �gure7.8 depicts a multidimensional state like we initially modeled.

Although we did not work out the details of this approach, we think that this approach hasa lot of potential and future research might focus on such an implementation of our model.

50

8. Conclusion

This chapter concludes our work on the prevention of supply chain issues during a new productdevelopment project.

First we will revisit both our research question and goals that we will complement with the�ndings from our research.

Second we will present the implications for both literature and practitioners.Finally we will end our conclusion by presenting the limitations of this research and our

recommendations for future research

8.1 Research question, goals and �ndings

Several undesirable supply chain situations were identi�ed within the Supplier Engineering andOutsourcing department of ASML. We found an example of a process that involves the suppliersinto the new product development project but fails to make the right decisions based on theirinput. We formulated the core of this problem to come to a more general research question andgoal.

• Research QuestionHow can we improve the assessment of a supply chain issue to make New Product Devel-opment decisions that ultimately prevent unfavorable supply chain situations?

• Goal 1Develop a model that includes supply chain interests and helps assess NPD decisions ontheir impact on project performance. This model should aid in �nding the decision thatoptimizes the project performance including supply chain performance.

A literature review led us to a real options model for making decisions during new productdevelopment (Huchzermeier and Loch, 2001) that originally excluded the in�uence of supplychain issues on project performance. We chose to use this model as the base for our own modeldevelopment and adapt it to our needs.

First we developed a concept for our model to de�ne how supply chain interests can be addedand how various parameters were related and in�uenced eachother. This was the base for themathematical model that was constructed afterwards. We found ourselves improving on threelimitations of current real options models for decision making during NPD.

Table 8.1 shows which limitations we encountered and improved upon by developing a model,thereby attaining Goal 1.

Limitation "old model" Implemented improvementSupply chain interests are ignored Supply chain performance parameters

are de�ned and added to the valuedriver performance

In�uences of the various dimensions ofperformance on eachother are neglected

An improvement matrix is de�ned instead of a vector, thereby de�ning thein�uence of parameters on eachother

Improvement impact is constant overtime and independent of current per-formance

Improvement impact is modeled as afunction of both time and current per-formance

Table 8.1: Improvements of our model

51

CHAPTER 8. CONCLUSION

With this concept and mathematical model, we answered the research question as well asgoal 1.

We also de�ned a second goal to increase the relevance of the research for the speci�c situationat ASML and at the same time o�er an opportunity to investigate an implementation of ourmodel.

• Goal 2Create a software tool that is an implementation of Goal 1 to enable two things; test themodel and serve as a tool for the decision making process itself.

To be able to develop a software implementation of the model, we used ASML as a case toinvestigate how supply chain performance could be measured. The parameters Quality, Logistics,Technology and Cost as identi�ed in our model were de�ned as measurable quantities usinginformation from interviews and documentation at ASML.

We found that going from our model to an actual implementation reintroduced a limitationthat we had solved in our model; the in�uence that the various dimensions of performance haveon eachother. This limitation reoccurred for two reasons. First we needed to avoid the need fortoo much computational power. Second it proved unrealistic to estimate the (future) in�uenceof the various parameters on eachother. At least at ASML where our implementation was basedon.

With this limitation identi�ed an application was developed to assess one value driver; Qual-ity. We used the de�nition for quality performance that was developed during our interviews atASML earlier.

Running tests with the application showed that our implementation led to di�erent conclu-sions both compared to current "gut feeling" at ASML and compared to existing real optionmodels from Huchzermeier and Loch (2001) and Santiago and Bifano (2005). Furthermore thebehavior of the software with extreme values proved to be normal. With this we also attainGoal 2.

8.2 Implications for literature and practitioners

8.2.1 Literature

Regarding our contribution to literature we have a number of implications.First we have extended the real option theory as it is used in new product development

projects to include supply chain performance considerations. We showed how it can be incor-porated in existing models and o�ered a possible implementation of measuring supply chainperformance, based on methods used at ASML.

Second we found that the current models show a multidimensional de�nition of performancebut fail to recognize the in�uence that the various dimensions have on eachother. We theno�ered an approach how to model this in�uence.

Third we o�ered an alternative way of dealing with the improve option that seems moreintuitive and realistic than currently is presented in literature. Rather than a static improve-ment impact we presented a method to make this impact dependent on both time and currentperformance. This appeals to both the intuition that the impact of an improvement is larger fora project that is just starting and the intuition that it is easier to improve a project with a badperformance.

Finally we made an actual implementation of (part of) the model that shows good resultsthereby reinforcing the theoretical model that we developed.

8.2.2 Practitioners

The implications that our research has for practitioners are as follows.

52

CHAPTER 8. CONCLUSION

Making the right decision now for a project that is just starting, calls for more then intuition.At the same time a software application like our own has limitations and can only be used tosupport a decision making process by providing insights into the situation. People involvedshould consider more than the software application and be aware of its limitations.

We o�er a prototype implementation of a decision model that can be build upon to becomea real tool for decision making during NPD. The source code can be found in appendix E andhas been commented throughout the code to make it easier to understand and adapt.

Finally we made a proposal how to measure supply chain performance based on what wefound at ASML.

8.3 Limitations and recommendations

We developed our model based on the problem that supply chain interests were not rightfullyassessed when new product development decisions are made. This led us to adapt an existingmodel for new product development decisions that only focused on technology. However, wedid not develop an ultimate model for new product development decisions that incorporateseverything. As an example, we did not look at the interests of e.g. a service organization.

We do think that our model is a solid base for further research that wants to include interestsfrom other parties outside the supply chain as well.

Previous real option models that we based our model on, made the assumption that animprovement action does not impact the development time. We adopted that limitation whilerealizing that this will not always be feasible.

We propose future research to look at how this in�uence of an improvement action on projectlead time can be modeled because project lead time also has an in�uence on project value thatis important.

Further limitations of our research are not on the model development but were introducedwith the actual implementation of our model in a software application that was based on theASML situation. These limitations are that our application:

1. is only "proof of concept" that focuses on 1 parameter only

2. does not consider in�uence of parameters on each other

3. is sensitive to data in a predictable way, but this concerns data that is hard to predict

4. has a �nite number of states per review and will thus always deviate from reality

The �rst limitation mentioned can be tackled by further developing our software. Thesoftware was already prepared to be extended with other value drivers and to easily adapt thevalue calculation for other value drivers.

The other limitations can be tackled not by the tool but by the usage of the tool. This meansrunning iterating simulations for a decision and running it again for every review moment.

Finally we o�ered a description of an alternative implementation in section 7.5.5 that alsodeals with the limitations mentioned.

53

Bibliography

Arden, W., M. Brillouet, P. Cogez, M. Graef, B. Huizing, and R. Mahnkopf, 2010: "more thenmoore" white paper.

ASML, 2010: Statutory annual report 2010. Internet.

ASML, 2011a: About asml.

ASML, 2011b: Statutory interim report for the six-month periond ended juna 26, 2011. Internet.

Barnett, M. L., 2005: Paying attention to real options. R&D Management, 35, 61�72.

Bidault, F., C. Despres, and C. Butler, 1998: The drivers of cooperation between buyers andsuppliers for product innovation. Research Policy, 26 (7-8), 719�732.

Boothroyd, G., 1994: Product design for manufacture and assembly. Computer-Aided Design,26 (7), 505�520, doi:10.1016/0010-4485(94)90082-5.

Boute, R., E. Demeulemeester, and W. Herroelen, 2004: A real options perspective on r&dportfolio diversi�cation. International Journal of Production Research, 42, 1715�1725, doi:DOI:10.1080/00207540310001639946.

Clark, K. B., 1989: Project scope and project performance: The e�ects of parts strategy andsupplier involvement on product development. Management Science, 35 (10), 1247�1263.

Cobb, B. R. and J. M. Charnes, 2007: Real options valuation. Proceedings of the 2007 Winter

Simulation Conference.

Dalgleish, G., G. Jared, and K. Swift, 2000: Design for assembly: In�uencing the design pro-cesses. Journal of Engineering Design, 11 (1), 17�29, doi:10.1080/095448200261162.

Davis, C. R., 2002: Calculated risk: A framework for evaluating product development. MIT

Sloan Management Review, 43, 70�78.

Dixit, A. K. and R. S. Pindyck, 1994: Investment under uncertainty. Princeton University Press.

Dowlatshahi, S., 1997: The role of product design in designer-buyer-supplier interface. Produc-tion Planning & Control, 8 (6), 522�532.

Echtelt, F. E. v., F. Wynstra, A. J. van Weele, and G. Duysters, 2008: Managing supplier in-volvement in new product development: A multiple-case study. Journal of Product InnovationManagement, 25, 180�201.

Eckhause, J. M., D. R. Hughes, and S. A. Gabriel, 2009: Evaluating real options for mitigatingtechnical risk in public sector r&d acquisitions. International Journal of Project Management,27, 365�377.

Fan, I.-S., S. Russel, and R. Lunn, 2000: Supplier knowledge exchange in aerospace productengineering. Aircraft Engineering and Aerospace Technology, 72 (1), 14�17.

Hand�eld, R. B., G. L. Ragatz, K. J. Petersen, and R. M. Monczka, 1999: Involving suppliersin new product development. California Management Review, 42 (1), 59�82.

54

BIBLIOGRAPHY

Hartley, J. L., J. R. Meredith, D. McCutcheon, and R. R. Kamath, 1997: Suppliers'contributionsto product development: An exploratory study. IEEE Transactions on Educationngineering

Management, 44, 258�267.

Hongfeng, P., L. Hongfang, and L. Min, 2008: Real options and process management of r&dprojects. International Conference on Information Management, Innovation Management and

Industrial Engineering, 157�162.

Huchzermeier, A. and C. H. Loch, 1999: Evaluating r&d projects as learning options: Why morevariability is not always better. Working paper.

Huchzermeier, A. and C. H. Loch, 2001: Project management under risk: Using the real optionsapproach to evaluate �exibility in R&D. Management Science, 47, 55�101, doi:10.1287/mnsc.47.1.85.10661.

ITRS, 2011: About itrs. URL http://www.itrs.net/about.html, URL http://www.itrs.net/about.html.

Kodukula, P. and C. Papudesu, 2006: Project Valuation Using Real Options: a practitioner's

guide. J.Ross Publishing.

Mathews, S., 2009: Valuing risky projects with real options. Research Technology Management,52, 32�41.

Meredith, J. R. and S. J. Mantel, 2002: Project Management: A managerial Approach. 5th ed.,John Wiley & Sons, Inc, 394-396 pp.

Moore, G. E., 1965: Cramming more components onto integrated circuits. Electronics, 114�117.

Myers, S. C., 1977: Determinants of corporate borrowing. Journal of Financial Economics, 5,147�175.

Parker, D. B., G. A. Zsidisin, and G. L. Ragatz, 2008: Timing and extent of supplier integrationin new product development: A contingency approach. Journal of Supply Chain Management,44 (1), 71�83.

Petersen, K. J., R. B. Hand�eld, and G. L. Ragatz, 2003: A model of supplier integrationinto new product development. The journal of Product Innovation Management, 20, 284�299,doi:10.1111/1540-5885.00028.

Petersen, K. J., R. B. Hand�eld, and G. L. Ragatz, 2005: Supplier integration into new productdevelopment: coordinating product, process and supply chain design. Journal of OperationsManagement, 23, 371�388, doi:10.1016/j.jom.2004.07.009.

Prasad, B., F. Wang, and J. Deng, 1998: A concurrent work�ow management processfor integrated product development. Journal of engineering Design, 9 (2), 121�135, doi:10.1080/095448298261589.

Primo, M. A. and S. D. Amundson, 2002: An exploratory study of the e�ects of supplierrelationships on new product development outcomes. Journal of Operations Management, 20,33�52.

Putten, A. B. v. and I. C. MacMillan, 2004: Making real options really work. Harvard Business

Review, 82, 134�141.

Ragatz, G. L., R. B.Hand�eld, and K. J. Petersen, 2002: Bene�ts associated with supplierintegration into product development under conditions of technology uncertainty. Journal ofBusiness Research, 55, 389�400.

55

http://www.itrs.net/about.html



BIBLIOGRAPHY

Ragatz, G. L., R. B. Hand�eld, and T. V. Scannell, 1997: Success factors for integrating suppliersinto new product development. The Journal of Product Innovation Management, 14 (3), 190�202, doi:10.1111/1540-5885.1430190.

Santiago, L. P. and T. G. Bifano, 2005: Management of r&d projects under uncertainty: Amultidimensional approach to managerial �exibility. IEEE Transactions on Engineering Man-

agement, 52, 269�280.

Santiago, L. P. and P. Vakili, 2005: On the value of �exibility in R&D projects. Management

Science, 8, 1206�1218.

Ulrich, K., D. Sartorius, S. Pearson, and M. Jakiela, 1993: Including the value of time in design-for-manufacturing decision making. Management Science, 39 (4), 429�447.

van Bekkum, S., E. Pennings, and H. Smit, 2009: A real options perspective on r&d portfoliodiversi�cation. Research Policy, 38, 1150�1158.

Wang, J., 2011: Flexible decision making in uncertain r/&d projects. International Conferenceon Uncertainty Reasoning and Knowledge Engineering.

Wang, J. and W. Hwang, 2007: A fuzzy set approach for r/&d portfolio selection using a realoptions valuation model. Omega, 35, 247 � 257.

Wasti, S. and J. Liker, 1997: Risky business or competitive power? supplier involvement injapanese product design. Journal of Product Innovation Management, 14 (5), 337�355, doi:10.1111/1540-5885.1450337.

Wynstra, F., A. J. van Weele, and M. Weggeman, 2001: Managing supplier involvement inproduct development: Three critical issues. European Management Journal, 19 (2), 157�167.

56

A. Abbreviations

In this research thesis a lot of abbreviations are used, both from literature and from ASML.Table A.1 gives an overview of all abbreviations used with their meaning and sometimes a shortexplanation.

Abbreviation MeaningCoG Cost of Goods, ASML terminology for the cost of a productCT Cycle Time, ASML terminology for the time it takes from order to delivery

without any available stock of (semi) �nished partsDCF Discounted Cash FlowDFMA Design For Manufacturing & AssemblyESI Early Supplier InvolvementIRR Internal Rate of ReturnITRS International Technology Roadmap for SemiconductorsMQP Material Quality Performance, ASML terminology for a quality performance

indicator based on the quotient of the amount of defects and the amount ofdeliveries

LSM Logistical Supply ManagerNPD New Product DevelopmentNPI New Product Introduction, ASML terminology for New Product Develop-

ment including market introductionNPV Net Present ValueOEM Original Equipment ManufacturerPAM Purchasing Account ManagerPER Proto Evaluation Report, a report in which the supplier can comment on the

design after having produced a prototype productQLTC Quality Logistics Technique Cost, ASML terminology referring to the multi-

dimensional focus of supplier performanceR&D Research and DevelopmentROA Real Option Analysis, not to be mistaken for "Return On Asset" as it is used

for in other contextsROI Return On InvestmentSAT Supplier Account Team, ASML terminology referring to the multi disci-

plinary team that works with the supplier to monitor and improve supplierperformance

SCE Supply Chain Engineer, an engineer involved with quality at the supplier andmanufacturability of the design.

SEO Supplier Engineering & Outsourcing, the ASML department where the prob-lem statement originated

TAS TPD Acceptance by Supplier, a form in which a supplier makes comments onthe design and declares the design to be manufacturable, given the comments

TPD Technical Product Documentation, the set of drawings and other speci�ca-tions that make up the design

TSM Technical Supplier ManagerWIP Work In Process

Table A.1: Abbreviations

57

B. Details on improvement impact

In the model as introduced by Huchzermeier and Loch (2001) and built upon by Santiago andVakili (2005) and Santiago and Bifano (2005), there is an assumption towards the impact of animprovement action. To explain this issue, we will �rst go over the way that the improvementoption is modeled in current literature.

Transition with-out improvement

Transition withimprovement

t t+1 t t+1 Project period

Product

Perform

ance

Improvementprobabilityshift

-1

0

1

2

Figure B.1: Transition probabilities of product performance as de�ned by Huchzermeier andLoch (2001)

Figure B.1 clari�es the impact of an improve action with an example that has 3 next possiblestates of performance. On the left we see that the next performance state in time, can havethree values due to chance. This would be the result of executing the option continue. Whenthe option improve is executed, the distribution of these performances remains, but the mean isshifted upwards as is seen on the right side of �gure B.1. The magnitude of this shift is 1 unit inthe example, but this can be any constant (although this is not speci�cally mentioned by eitherHuchzermeier and Loch (2001) or Santiago and Vakili (2005)). If this constant is within theinteger space, this simpli�cation leads to a convenient recombining lattice that is a little easierto calculate.

When looking at one decision only, this assumption does not strike as a problem. Butlooking at a whole project tree, this way of dealing with the improvement option seems to beunrealistically static. Figure B.2 clari�es this with a small tree. The black lattice tree in �gureB.2 is a tree that �ts to a project with only the decision to continue. For three decision pointsA, B and C, the option to improve is added in green and the impacts of those improvements areshown in red. This shows that the impact of the improvement actions for A, B and C result inthe same mean shift of the performance.

A �rst remark on the current model (illustrated in �gure B.2) is that it seems unrealisticto think that the impact of an improvement action would be the same throughout the project.This situation is illustrated with decision point A occurring in the beginning of the project anddecision points B and C occurring towards the end of the project. Improve A, Improve B andImprove C in �gure B.2 have the same mean shift of performance. However, in practice a projectthat is almost �nished is a lot harder to improve than a project that just started. Especiallyconsidering the assumption Huchzermeier and Loch (2001) make that an improvement actionis executed parallel to the project and thus does not delay the project. Considering all this, itseems unrealistic to assume that the impact of an improvement is equal throughout the duration

58

APPENDIX B. DETAILS ON IMPROVEMENT IMPACT

Time

Product

Perfor-

manceA

B

C

Improve A

Improve C

Improve B

Improve

Continue

Figure B.2: Impact of improvement independent from time and current performance

of the new product development project.This can not be changed by simply changing the parameters of values of the current model

due to the fact that every change like e.g. adding more nodes or changing the distribution atthe end of the tree, not only e�ects the improvement option, but also the continue option. Thecurrent model does not allow to change the improvement option independent from the continueoption and at the same time dependent on time and current performance.

A second remark on the current model is that the impact of the improvement is assumed tobe independent o� the actual current performance. This is illustrated in �gure B.2 with decisionpoints B and C. Both improvement actions lead to the same mean shift of performance whilethere is much more room for improvement in C then in B. In other words, the performance in Cis really bad and the performance in B is very good. It should be easier to improve when currentperformance is extremely bad then it is when current performance is almost perfect. Therefore,it seems also unrealistic to assume that the impact of an improvement is independent from theactual current performance.

Note that in the current model the payo� distribution at the end of the lattice tree (�gure 4.1)can be altered to incorporate all kinds of e�ects. This would however both impact the continueoption (change due to chance only) as well as the improve option. Furthermore, Huchzermeierand Loch (2001) do not mention this alteration of the distribution as a mean for any kind ofe�ect although it would be an important implication for practitioners.

59

C. Calculations to aid in Model

automation

To create a tree, several steps have to be made that are described in this chapter. The steps arethe following:

1. Determine number of end nodes for continue only

2. Determine the scale of performance

3. Expand scale to include the improve option

4. Build tree from left to right including both improve and continue

5. Evaluate from right to left all nodes.

(a) Calculate node value for improve node and continue node

(b) Delete node with lowest value

C.1 Number of End nodes for continue

To calculate the number of end nodes for a tree that does not include the improve option, weneed to know two things:

1. Number of review points in time (T )

2. Per review moment, number of possible outcomes (nt)

When only continue takes place, the base of the model is a recombining lattice tree with sym-metric (risk neutral) distribution for the performance. The interval value for the scale that isused by this tree will be 1. If we start the project at time t = 0, the formula for the number ofend nodes N can be calculated with

N = 1 +T−1∑t=1

(n− 1)

In the model, remember I choose that all next states are "1" unit apart of each other, independentof how many next stages there are. The tree in �gure C.2 shows this by showing the values ofthe lattice trees with n = 3 at t = 0 and n = 2 at t = 1. Please note that n describes theamount of next possible states per node. Now that we can calculate the number of end nodes inthe case that no improve action could be taken, we can go to the next step, project the expertopinion on the performance range that the tree show in its end nodes.

C.2 Scale of performance

The model makes use of this basic tree to determine the range of the scale that will be usedfor the project outcome. Since I assume that the project is not biased but has a risk-neutralattitude, the median of the outcomes should be zero. The range of the scale is now de�ned by

Range =

[0− Nrofendnodes− 1

2; 0 +

Nrofendnodes− 1

2

]60

APPENDIX C. CALCULATIONS TO AID IN MODEL AUTOMATION

0 1 23 2

3/2

1

1/2

0 0

−1/2

−1

−3/2

t =n =

Number of end nodes:N = 1 + (3− 1) + (2−1) = 4

Note how the di�erencebetween the outcomes are1, both at t = 1 withn = 3 and at t = 2 withn = 2

Figure C.1: Tree with di�erent n's, T = 3

Now that we have a tree and its scale for the project were improvement is not one of theoptions, we need to project the expected performance distribution (expert opinion) on this scale.To do so, we ask the expert to give an estimate (for the situation were no improvement is done)for the worst, best and most likely performance at the end of the project. The result of this isprojected as a triangular distribution against the current scale of the tree. Figure ?? shows anexample of this using a case of the following estimates yields :

• Worst : 70%

• Most likely : 90%

• Best: 95%

0

1

0

-1

1.5

0.5

-0.5

-1.5

Best = 95%

Most Likely= 90%

Worst = 80%

Figure C.2: Projecting the expert's opinion on the tree scale

As the picture shows, the most likely estimate is projected at the 0 point of the current scalein the tree, since this is the expected end result of a risk-neutral attitude. Now that we havethe expert opinion projected on the performance range of the tree, we can expand the range toinclude the improve option.

C.3 Expand scale to include improve option

There are now two functions to translate the result of the tree to an actual performance unit, inthis case a yield percentage. As we saw in �gure C.2, this function might be di�erent for values

61


below zero and values above zero, depending on wether or not the expert opinion on the mostlikely result is the mean of the worst and best result. The estimates of the expert are still basedon a project were no extra e�ort is done to improve the performance. For the next step, we needto consult the expert on the best possible performance, but now given that improve actions arean option. In the case of a Yield performance, we could set this on a yield of 100%.

090%

11.52

3

4

95% 100%Yield [%]

Tree value

f(x) = 0.3(x− 90)

Figure C.3: Function to describe relation of tree values with Yield

Figure C.3 shows the graph of the function that relates the value of a tree node to an actualyield as was estimated by the expert. If we now use the maximum performance de�ned whenimprovement option is included, we can extrapolate this function to get the tree value for thismaximum performance. For our example this would lead to:

Nval(y) = 0.3 ∗ 100%− 90 = 3

With Nval(y) being the value of a node in the tree (above zero!) as a function of yield y. Theresult matches again graph C.3. A more general way to calculate this value would be:

NMaxI = NMaxC + (PBestI − PBestC) ∗NMaxC

PBestC − PMostlikely

Before I continue to the next step were the tree will be build from left to right, I will �rstshow how to create the functions that are needed to calculate an expected yield from a knownperformance level. That is in fact, the inverse of what was shown just before. For building thetree and calculating the expected performance in every node, we use the scale of the tree that islinear and then calculate the expected yield that was projected against this scale as explainedin section C.2.

There are a few things that are known, �rst the function will be linear and thus in the formf(x) = ax + b. Second, since at x = 0 we have the most likely value of performance, b mustequal the most likely performance value. Third, we �nd a by dividing the di�erence between theperformance values of "Best" and""Most likely" with the scale value of the "Best" performance1.Now the function is de�ned by:

Phigh(x) =Pbest − Pmost likely

Sbestx+ Pmost likely

In this formula Phigh(x) is the performance value as a function of the tree performance scale.x, Pbest and Pmost likely are the expert opinion on the best and most likely performance whencontinue is the only option, and Sbest is the scale value (at the end of the tree) of the expertopinion on the best performance. This formula is only valid for tree performances values of 0and larger which is the upper part of the tree (hence the name Phigh.

1The scale value of the "Most Likely" performance is zero so there is no need to subtract that.

62


Analogue to this, the function for performances that lie below the most likely performancecan be de�ned. If we combine the two we get:

P (x) =

{Pbest−Pmost likely

Sbestx+ Pmost likely if x ≥ 0

Pmost likely−Pworst

−Sworstx+ Pmost likely if x ≤ 0

These equations are needed because with the improve action as I have implemented, performancevalues will no longer be on the �xed interval scale that the initial tree for continue consisted of. Ionly needed to do calculations on the normal continue tree to get the range of the scale that wasneeded. Remember that in the beginning I set the continue option to result in performances thathave a di�erence of 1 unit on the "tree scale". That was the starting point of the calculations.

63

D. Sensitivity tests

For all sensitivity test, the same project data was �lled in as shown in table D.1. The data forthe reviews was changed according to the description beneath all output graphs in this appendix.The standard from which all tests deviate, can be found in table D.2 below.

Parameter Value Parameter ValueReviews 4 Worst Expected 75%

Discount Rate 0.02 Most Likely 90%Cost of Goods e25000 Best Expected 95%

Products / Year 120 Best Possible 100%Payback Period 2 Target 99%

Table D.1: Overall project data - sensitivity tests

Review t= 0 1 2 3Cost to Continue 0 0 0 0Cost to Improve e60k e120k e180k e240kImprovement % 50% 40% 25% 5%Next states [#] 4 3 2 2

Chances 20% 30% 50% 50%30% 40% 50% 50%30% 30%20%

Table D.2: Review data - sensitivity tests

Figure D.1: All improvement cost set to e100

64

APPENDIX D. SENSITIVITY TESTS

Figure D.2: All improvement cost set to e800k

Figure D.3: All improvement percentages set to 80%

Figure D.4: All improvement percentages set to 5%

65


Figure D.5: All Nr of Next Possible States set to 2

66


Figure D.6: All Nr of Next Possible States set to 5

67


Figure D.7: All improvement cost set to e120k, all improvement percentages to 30%

68

E. Source code

E.1 Main.java

1 package npd_supplychain_strategist;

3 /***

5 * @author Mathijs van Suilichem

*/7 public class Main {

9 /*** @param args the command line arguments

11 */public static void main(String[] args) {

13

Project project = new Project();15 if (args.length == 1) {

project.startAndOpen(args[0]);17 }

else {19 project.start();

}21

}23

}

E.2 Project.java

package npd_supplychain_strategist;2 import javax.swing.*;import javax.swing.filechooser.*;

4 import java.awt.*;import java.awt.event.*;

6 import java.awt.print.*;import java.io.File;

8 /***


*/12 public class Project {

14 private String baseTitle = "Project Decision Analyzer";

16 ProjectPanel projectPanel;ReviewPanel reviewPanel;

18 NetworkCanvas nodenet;JScrollPane canvas;

20 JFrame frame;boolean msg; //flag

22

//MenuItems24 MenuItem newFile;

MenuItem openFile;26 MenuItem saveFile;

MenuItem printTree;

69

APPENDIX E. SOURCE CODE

28 MenuItem author;

30 public Project() {projectPanel = new ProjectPanel();

32 reviewPanel = new ReviewPanel();nodenet = new NetworkCanvas();

34

}36 public void start() {

38 //make dummy tree with no reviews to prevent calls to empty objects//DecisionTree dTree = DecisionTree.getInstance(0);

40 frame = new JFrame();frame.setTitle(baseTitle);

42 frame.setMenuBar(initMenuBar());

44

projectPanel.registerForFrameChanges(frame);46 reviewPanel.registerForRepaintRequest(frame);

nodenet.registerForRepaintRequest(frame);48

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);50

JScrollPane canvas = new JScrollPane(nodenet);52 frame.getContentPane().add(BorderLayout.CENTER,canvas);

frame.getContentPane().add(BorderLayout.NORTH,projectPanel);54 frame.getContentPane().add(BorderLayout.SOUTH,reviewPanel);

56

frame.setMinimumSize(new Dimension(1000,700));58 if (frame.getExtendedState()!= JFrame.MAXIMIZED_BOTH) {

frame.setExtendedState(JFrame.MAXIMIZED_BOTH);60 }

frame.setVisible(true);62 }

64 public void startAndOpen(String FileName) {start();

66 String[] fileN = FileName.split("/"); //Get the name without the pathString fileName = fileN[fileN.length-1];

68 frame.setTitle(baseTitle + " - " + fileName);DecisionTree.createFromFile(new File(FileName));

70 frame.repaint();}

72

private MenuBar initMenuBar() {74 MenuBar m = new MenuBar();

76 //Create and label MenusMenu file = new Menu("File");

78 Menu about = new Menu("About");

80 //create and label menu ItemsnewFile = new MenuItem("New",new MenuShortcut(KeyEvent.VK_N));

82 newFile.addActionListener(new MenuListener());openFile = new MenuItem("Open",new MenuShortcut(KeyEvent.VK_O));

84 openFile.addActionListener(new MenuListener());saveFile = new MenuItem("Save",new MenuShortcut(KeyEvent.VK_S));

86 saveFile.addActionListener(new MenuListener());printTree = new MenuItem("Print",new MenuShortcut(KeyEvent.VK_P));

88 printTree.addActionListener(new MenuListener());author = new MenuItem("Author");

90 author.addActionListener(new MenuListener());

70


92 //Add menu Items to menusfile.add(newFile);

94 file.add(openFile);file.add(saveFile);

96 file.add(printTree);about.add(author);

98

//add menus to menu bar100 m.add(file);

m.add(about);102 return m;

}104

class MenuListener implements ActionListener {106

public void actionPerformed(ActionEvent event) {108 if (event.getSource() == newFile) {

// @todo does not work right at this moment. Current tree gets notdeleted well

110 frame.setTitle(baseTitle);DecisionTree.removeTree();

112 projectPanel.emptyValues();frame.repaint();

114 }if (event.getSource() == openFile) {

116 JFileChooser fc = new JFileChooser();fc.setCurrentDirectory(new File("H:/Private + study/Master_Thesis/

Thesis/Model/TestFiles/")); //@todo delete defautl dir118 fc.setAcceptAllFileFilterUsed(false);

fc.setFileFilter(new FileNameExtensionFilter("XML File","xml"));120 fc.showOpenDialog(frame);

File fileToOpen = fc.getSelectedFile();122 String[] fileN = fc.getName(fileToOpen).split("/"); //Get the

name without the pathString fileName = fileN[fileN.length-1];

124 frame.setTitle(baseTitle + " - " + fileName);DecisionTree.createFromFile(fileToOpen);

126 frame.repaint();}

128 else if (event.getSource() == saveFile) {JFileChooser fc = new JFileChooser();

130 fc.setCurrentDirectory(new File("H:/Private + study/Master_Thesis/Thesis/Model/TestFiles/")); //@todo delete defautl dir

fc.setAcceptAllFileFilterUsed(false);132 fc.setFileFilter(new FileNameExtensionFilter("XML File","xml"));

fc.showSaveDialog(frame);134 File fileToSave = fc.getSelectedFile();

if (!fileToSave.getName().endsWith(".xml")) {136 fileToSave = new File(fileToSave.getAbsolutePath() + ".xml");

}138 DecisionTree.saveToFile(fileToSave);

frame.repaint();140 }

else if (event.getSource() == printTree) {142 PrinterJob job = PrinterJob.getPrinterJob();

PageFormat pf = job.defaultPage();144 Paper paper = new Paper();

double margin = 36;146 paper.setImageableArea(margin, margin, paper.getWidth()-margin*2,

paper.getHeight()-margin*2);pf.setPaper(paper);

148 job.setPrintable(nodenet,pf);

71


150 boolean doPrint = job.printDialog();if (doPrint) {

152 try {job.print();

154 }catch (PrinterException e) {

156

}158 }

//@todo nog programmeren of weghalen160 }

else if (event.getSource() == author) {162 String msg = "This software was programmed as part \nof my Master’

s Thesis project \nfor the Master programm \nInnovationManagement "

+ "\nat Eindhoven University, \nThe Netherlands" + "\n \nMathijs van Suilichem \n+31653409988" +

164 "\nDec 2011";JOptionPane.showMessageDialog(null,msg);

166 }}

168 }

170 }

E.3 Connection.java

package npd_supplychain_strategist;2

/**4 *

* @author Mathijs van Suilichem6 */public class Connection {

8

private TreeNode fromNode;10 private TreeNode toNode;

private double toModelPerformanceValue;12 private byte type;

double chance;14

public Connection(TreeNode From, byte Type, double Chance, doubleToPerformanceValue){

16 this.fromNode = From;this.type = Type;

18 this.chance = Chance;this.toModelPerformanceValue = ToPerformanceValue;

20 }

22 public void setToNode(TreeNode node) {this.toNode = node;

24 }public TreeNode getToNode() {

26 return this.toNode;}

28 public void setFromNode(TreeNode node) {this.fromNode = node;

30 }public TreeNode getFromNode() {

32 return this.fromNode;}

34 public double getNextPerformanceValue() {

72


return this.toModelPerformanceValue;36 }

38 public byte getType() {return this.type;

40 }}

E.4 DecisionTree.java

1 package npd_supplychain_strategist;import java.util.ArrayList;

3 import java.awt.*;import javax.swing.*;

5 import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.DocumentBuilder;

7 import javax.xml.transform.Transformer;import javax.xml.transform.TransformerException;

9 import javax.xml.transform.TransformerFactory;import javax.xml.transform.dom.DOMSource;

11 import javax.xml.transform.stream.StreamResult;import org.w3c.dom.Document;

13 import org.w3c.dom.NodeList;import org.w3c.dom.Node;

15 import org.w3c.dom.Element;import java.io.File;

17

/**19 *

* @author Mathijs van Suilichem21 */

23 public class DecisionTree {

25 //<editor-fold defaultstate="collapsed" desc="Local Variables">private double r; //discountrate for one period

27 private boolean includeAbandon;private int T; //number of reviewmoments

29 private double[] modelPerformances; //position 0 is minimum, 1 is most likely,2 is maximum, 3 is maximum with improvement unit is here with grid !!!

private double[] estimatedPerformances; //position 0 is minimum, 1 is mostlikely, 2 is maximum, 3 is maximum with improvement

31 private double targetPerformance;private int offsetX,offsetY;

33 private boolean treeHasBeenBuilt;ArrayList<TreeNode> allNodes = new ArrayList<TreeNode>();

35 ArrayList<Review> allReviews = new ArrayList<Review>();private double CoG;

37 private int nrOfYearsPayback;private int nrOfProductPerYear;

39 private boolean hideDisconnectedNodes;private int lowestPerfNode;

41 private static DecisionTree uniqueInstance;//Following names are exactly like the spelling in the xml file, so do not

change43 private static String[] projectVariables = {"nrOfYearsForReturn","

nrOfProductsPerYear","costOfGoods","nrOfReviews","discountRate"};private static String[] treeVariables = {"worstExpected", "mostLikely", "

bestExpected","bestPossible","target"}; //Do not change order!!!45 private static String[] reviewVariables = {"time", "costToContinue", "

costToImprove","improvementPercentage","nrOfNextPossibleStates","chances"};//</editor-fold>

47

73


//<editor-fold defaultstate="collapsed" desc="Constructor singleton + remover">49 private DecisionTree(int NrOfReviews) {

this.T = NrOfReviews;51 for (int i=0; i<NrOfReviews; i++) {

allReviews.add(new Review(i));53 }

estimatedPerformances = new double[4]; //0 is minimum, 1 is mostlikely, 2 is maximum, 3 is maximum with improvement

55 modelPerformances = new double[4]; //0 is minimum, 1 is mostlikely, 2 is maximum, 3 is maximum with improvement

treeHasBeenBuilt = false;57 offsetX = Tree.OFFSET_X;

offsetY = Tree.OFFSET_Y;59 hideDisconnectedNodes = false;

includeAbandon = false;61 }

//Prevent problems with multithreading63 private synchronized static void createInstance(int NrOfReviews) {

if (uniqueInstance == null) {65 uniqueInstance = new DecisionTree(NrOfReviews);

}67 }

69 public static DecisionTree getInstance(int NrOfReviews) {if (uniqueInstance == null) {

71 createInstance(NrOfReviews);}

73 else if (uniqueInstance.T < NrOfReviews) {for (int i=uniqueInstance.T+1; i<=NrOfReviews; i++) {

75 uniqueInstance.allReviews.add(new Review(i));}

77 uniqueInstance.T = NrOfReviews;}

79 else if (uniqueInstance.T > NrOfReviews) {for (int i=uniqueInstance.T-1; i>=NrOfReviews; i--) {

81 uniqueInstance.allReviews.remove(i);}

83 uniqueInstance.T = NrOfReviews;}

85 return uniqueInstance;}

87

public static DecisionTree getInstance() {89 return uniqueInstance;

}91

public static void removeTree() {93 if (uniqueInstance != null) {

uniqueInstance = null;95 }

}97 //</editor-fold>

99 //<editor-fold defaultstate="collapsed" desc="File handling">public static void createFromFile(File XmlFile) {

101 removeTree(); //First remove any possible existing treeString errorMsg = "";

103 boolean errorOccurred = false;try {

105 DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();

107 Document doc = dBuilder.parse(XmlFile);doc.getDocumentElement().normalize();

74


109 Element root = doc.getDocumentElement();DecisionTree dTree;

111

//first get the overall project variables113

int nrOfReviews = Integer.parseInt(getTagValue(projectVariables[3],root));115 dTree = DecisionTree.getInstance(nrOfReviews);

dTree.setNrOfYearsPayback(Integer.parseInt(getTagValue(projectVariables[0],root)));

117 dTree.setNrOfProductsPerYear(Integer.parseInt(getTagValue(projectVariables[1],root)));

dTree.setCoG(Double.parseDouble(getTagValue(projectVariables[2],root)));119 dTree.setDiscountRate(Double.parseDouble(getTagValue(projectVariables[4],

root)));

121 //now get the actual tree for e.g yieldPerformanceElement tree = (Element)doc.getElementsByTagName("yieldPerformance").item

(0); //@todo veranderen als je ook L en C boom wilt123 for (int i=0; i<4; i++) {

dTree.setEstimatedPerformance(Double.parseDouble(getTagValue(treeVariables[i],tree)), i);

125 }dTree.setTargetPerformance(Double.parseDouble(getTagValue(treeVariables[4],

tree)));127 //@todo delete check for XML data

NodeList reviews = tree.getElementsByTagName("review");129 for (int i=0; i < reviews.getLength(); i++) {

Node reviewNode = reviews.item(i);131 int time=0;

double cost2Continue=0;133 double cost2Improve=0;

int nrOfNextStates=0;135 double improvePercentage = 0;

double[] chances = {0};137 if (reviewNode.getNodeType() == Node.ELEMENT_NODE) {

Element eElement = (Element) reviewNode;139 time = Integer.parseInt(getTagValue(reviewVariables[0],eElement));

cost2Continue = Double.parseDouble(getTagValue(reviewVariables[1],eElement));

141 cost2Improve = Double.parseDouble(getTagValue(reviewVariables[2],eElement));

improvePercentage = Double.parseDouble(getTagValue(reviewVariables[3],eElement));

143 nrOfNextStates = Integer.parseInt(getTagValue(reviewVariables[4],eElement));

chances = new double[nrOfNextStates];145 Element chanceTree = (Element)eElement.getElementsByTagName(

reviewVariables[5]).item(0);NodeList chanceList = chanceTree.getElementsByTagName("chance");

147 for (int j=0; j<nrOfNextStates; j++) {Node chance = chanceList.item(j);

149 chances[j] = Double.parseDouble(chance.getChildNodes().item(0).getNodeValue());

}151 }

//now create review and add to the arraylist153 Review rev = new Review(time,cost2Continue,cost2Improve,nrOfNextStates,

improvePercentage,chances);dTree.allReviews.set(i, rev);

155 }}

157 catch (javax.xml.parsers.ParserConfigurationException pce) {errorMsg = "The parser was not configured correctly.";

75


159 errorOccurred = true;}

161 catch (java.io.IOException ie) {errorMsg = "Cannot read input file.";


165 catch (org.xml.sax.SAXException se) {errorMsg = "Problem parsing the file.";


169 catch (java.lang.IllegalArgumentException ae) {errorMsg = "Please specify an XML source.";


173 catch (Exception e) {errorMsg = "Error5: " + e.toString();


177 finally {if (errorOccurred) {

179 JOptionPane.showMessageDialog(null, errorMsg);}

181 }}

183

public static void saveToFile(File XmlFile) {185 String errorMsg = "";

boolean errorOccurred = false;187 if (!DecisionTree.exists()) {

JOptionPane.showMessageDialog(null,"There was no tree created yet! Nothingto be saved");

189 return;}

191 try {DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

193 DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();Document doc = dBuilder.newDocument();

195 Element root = doc.createElement("project");doc.appendChild(root);

197 DecisionTree dTree = uniqueInstance;

199 //first set the overall project variablesElement payBackYears = doc.createElement(projectVariables[0]);

201 payBackYears.appendChild((doc.createTextNode(Integer.toString(dTree.getNrOfYearsPayback()))));

Element prodPerYear = doc.createElement(projectVariables[1]);203 prodPerYear.appendChild(doc.createTextNode(Integer.toString(dTree.

getNrOfProductsPerYear())));Element coG = doc.createElement(projectVariables[2]);

205 coG.appendChild(doc.createTextNode(Double.toString(dTree.getCoG())));Element nrOfRevs = doc.createElement(projectVariables[3]);

207 nrOfRevs.appendChild(doc.createTextNode(Integer.toString(dTree.getNrOfReviews())));

Element discountRate = doc.createElement(projectVariables[4]);209 discountRate.appendChild(doc.createTextNode(Double.toString(dTree.

getDiscountRate())));root.appendChild(payBackYears);

211 root.appendChild(prodPerYear);root.appendChild(coG);

213 root.appendChild(nrOfRevs);root.appendChild(discountRate);

215

//now get the actual tree for e.g yieldPerformance

76


217 Element yieldTree = doc.createElement("yieldPerformance"); //@todoveranderen als je ook L en C boom wilt

root.appendChild(yieldTree);219 for (int i=0; i<4; i++) {

Element e = doc.createElement(treeVariables[i]);221 e.appendChild(doc.createTextNode(Double.toString(dTree.

getEstimatedPerformance(i))));yieldTree.appendChild(e);

223 }//now also save the target value

225 Element e = doc.createElement(treeVariables[4]);e.appendChild(doc.createTextNode(Double.toString(dTree.getTargetPerformance

())));227 yieldTree.appendChild(e);

229 //@todo delete check for XML dataint T = dTree.getNrOfReviews();

231 for (int i=0; i < T; i++) {Element reviewNode = doc.createElement("review");

233 Review rev = dTree.getReview(i);Element time = doc.createElement(reviewVariables[0]);

235 time.appendChild(doc.createTextNode(Integer.toString(rev.getTime())));

Element c2c = doc.createElement(reviewVariables[1]);237 c2c.appendChild(doc.createTextNode(Double.toString(rev.

getCost2Continue())));Element c2i = doc.createElement(reviewVariables[2]);

239 c2i.appendChild(doc.createTextNode(Double.toString(rev.getCost2Improve())));

Element improvePer = doc.createElement(reviewVariables[3]);241 improvePer.appendChild(doc.createTextNode(Double.toString(rev.

getImprovementPercentage())));Element nextN = doc.createElement(reviewVariables[4]);

243 nextN.appendChild(doc.createTextNode(Integer.toString(rev.getNrOfNextStates())));

Element chanceTree = doc.createElement(reviewVariables[5]);245 int nrOfChances = rev.getNrOfNextStates();

for (int j=0; j<nrOfChances; j++) {247 Element chance = doc.createElement("chance");

chance.appendChild(doc.createTextNode(Double.toString(rev.getChances()[j])));

249 chanceTree.appendChild(chance);}

251 reviewNode.appendChild(time);reviewNode.appendChild(c2c);

253 reviewNode.appendChild(c2i);reviewNode.appendChild(improvePer);

255 reviewNode.appendChild(nextN);reviewNode.appendChild(chanceTree);

257 yieldTree.appendChild(reviewNode);}

259 //write context to xml fileTransformerFactory transformerFactory = TransformerFactory.newInstance();

261 Transformer transformer = transformerFactory.newTransformer();DOMSource source = new DOMSource(doc);

263 StreamResult result = new StreamResult(XmlFile);transformer.transform(source, result);

265 }catch (javax.xml.parsers.ParserConfigurationException pce) {

267 errorMsg = "The parser was not configured correctly.";errorOccurred = true;

269 }catch (TransformerException tfe) {

77


271 errorMsg = tfe.getMessage();errorOccurred = true;

273 }catch (java.lang.IllegalArgumentException ae) {

275 errorMsg = "Please specify an XML source.";errorOccurred = true;

277 }catch (Exception e) {

279 errorMsg = "Error5: " + e.toString();errorOccurred = true;

281 }finally {

283 if (errorOccurred) {JOptionPane.showMessageDialog(null, errorMsg);

285 }}

287 }//</editor-fold>

289

//<editor-fold defaultstate="collapsed" desc="Getters and Setters">291 public void setEnableAbandon(boolean Enable) {

this.includeAbandon = Enable;293 }

public boolean getAbandonEnabled() {295 return this.includeAbandon;

}297 public void setEstimatedPerformance(double Performance, int Type) {

estimatedPerformances[Type] = Performance;299 }

public double getEstimatedPerformance(int Type) {301 return estimatedPerformances[Type];

}303 public void setTargetPerformance(double Target) {

targetPerformance = Target;305 }

public double getTargetPerformance() {307 return targetPerformance;

}309 public void setNrOfReviews(int Nr) {

this.T = Nr;311 }

public int getNrOfReviews() {313 return this.T;

}315

public void setDiscountRate(double r) {317 this.r = r;

}319 public double getDiscountRate() {

return r;321 }

public void setCoG(double CostOfGoods) {323 this.CoG = CostOfGoods;

}325 public double getCoG() {

return this.CoG;327 }

public void setNrOfYearsPayback(int NrOfYears) {329 this.nrOfYearsPayback = NrOfYears;

}331 public int getNrOfYearsPayback() {

return this.nrOfYearsPayback;333 }

78


public void setNrOfProductsPerYear(int NrOfProducts) {335 this.nrOfProductPerYear = NrOfProducts;

}337 public int getNrOfProductsPerYear() {

return this.nrOfProductPerYear;339 }

public void hideUnreachableStates(boolean Hide) {341 this.hideDisconnectedNodes = Hide;

}343 public Review getReview(JComponent reviewField) {

Review reviewReturn = null;345 for (Review rev : allReviews) {

ArrayList<JComponent> revFields = rev.getFields();347 for (JComponent revField : revFields) {

if (revField == reviewField) {349 reviewReturn = rev;

}351 }

}353 return reviewReturn;

}355 public Review getReview(int Time) {

return allReviews.get(Time);357 }

//</editor-fold>359

//<editor-fold defaultstate="collapsed" desc="Other ...">361 public Dimension getDimension() {

Dimension d = new Dimension();363 d.width = this.T * Tree.VECTOR_X + 3*Tree.OFFSET_X;

d.height = (int) (Tree.VECTOR_Y * (this.modelPerformances[Tree.BEST_POSSIBLE] - this.lowestPerfNode)) + 2 * Tree.OFFSET_Y;

365 return d;}

367

public static boolean exists() {369 if(uniqueInstance == null) {

return false;371 }

else {373 return true;

}375 }

377 public boolean isBuilt() {return this.treeHasBeenBuilt;


381

//<editor-fold defaultstate="collapsed" desc="Build and calculate tree">383 public void buildTree() {

calcModelPerformances();385 this.offsetY = Tree.OFFSET_Y + (int)this.modelPerformances[Tree.

BEST_POSSIBLE]*Tree.VECTOR_Y; //adapt the offset to height of the treeemptyTree();

387 IntermediateNode node;EndNode endNode;

389 Review review;

391 //create the first node, add to the list and get the connectionsreview = this.allReviews.get(0);

393 node = new IntermediateNode(0,0,review.getNrOfNextStates(),review.getChances(),review.getImprovementPercentage(),modelPerformances[Tree.

79


BEST_POSSIBLE]);node.setLocation(offsetX, offsetY);

395 node.setConnected(true);allNodes.add(node);

397 ArrayList<IntermediateNode> nodesForNextreview = new ArrayList<IntermediateNode>();

ArrayList<IntermediateNode> nodesForThisreview = new ArrayList<IntermediateNode>();

399 nodesForNextreview.add(node);Review nextReview = null;

401 for (int i=0; i<T; i++) { //Loop through all review momentsif (!nodesForThisreview.isEmpty()) { nodesForThisreview.clear(); } //

Empty arraylist if it is not empty403 for (IntermediateNode n : nodesForNextreview) {

//first copy all elements405 nodesForThisreview.add(n);

}407 //now empty the new nodes so that we can fill it for the next loop

nodesForNextreview.clear();409 if (i<T-1) { nextReview = this.allReviews.get(i+1); } //because we

will be intializing the nodes for the next reviewfor (IntermediateNode n : nodesForThisreview) {

411 ArrayList<Connection> cons = n.getConnectionsTo();for (Connection c : cons) {

413 if ( i<T-1) {node = (IntermediateNode)getNode(i+1,c.

getNextPerformanceValue()); //this is the node towhich current node is connected

415 if ( node == null) { //only create if node for thatvalue at that time does not exist and no nodes for endof treenode = new IntermediateNode(i+1,c.

getNextPerformanceValue(),nextReview.getNrOfNextStates(),nextReview.getChances(),

417 nextReview.getImprovementPercentage(),modelPerformances[Tree.BEST_POSSIBLE]);

node.setLocation(offsetX+(i+1)*Tree.VECTOR_X, offsetY -(int)(c.getNextPerformanceValue()*Tree.VECTOR_Y));

419 c.setToNode(node);node.connectionsFrom.add(c);

421 node.setConnected(true);this.allNodes.add(node);

423 nodesForNextreview.add(node);}

425 else {c.setToNode(node); //Node already exists, so only add

the node to the current connection427 node.connectionsFrom.add(c); //also add the connection

to the next node}

429 }else {

431 endNode = (EndNode)getNode(i+1,c.getNextPerformanceValue()); //i == T-1

if(endNode == null) { //create the endnodes433 endNode = new EndNode(i+1,c.getNextPerformanceValue());

endNode.setLocation(offsetX+(i+1)*Tree.VECTOR_X,offsetY - (int)(c.getNextPerformanceValue()*Tree.VECTOR_Y));

435 endNode.connectionsFrom.add(c);c.setToNode(endNode);

437 endNode.setConnected(true);this.allNodes.add(endNode);

80


439 }else {

441 endNode.connectionsFrom.add(c);c.setToNode(endNode); //Node already exists, so only

add the connection);443 }

}445 }

}447 }

this.treeHasBeenBuilt = true;449 }

451 public void calculateTree(ValueCalculator Calculator) {ArrayList<TreeNode> nodes;

453 if (!this.isBuilt()) { return; } //check wether the tree was built (uncalculated) in the first place

//First fill the values for the endnodes455 nodes = getNodesForReview(T);

for (TreeNode n : nodes) { //walk through all the endnodes anddetermine value and performance

457 double performance = calcPerformance(n.modelPerformance);n.expectedPerformance = performance;

459 n.value = Calculator.calculateValue(performance);}

461 for (int t=T-1; t>=0; t--) { //walk from right to left through tree todetermine the right decision and delete unreachable nodesReview rev = allReviews.get(t);

463 nodes = getNodesForReview(t);for (TreeNode n : nodes) { //walk through all the nodes at this

reviewmoment465 IntermediateNode iNode = (IntermediateNode)n;

iNode.expectedPerformance = calcPerformance(iNode.modelPerformance); //calculate actual performance from modelperformance

467 double[] decisionValues = iNode.getDecisionAdvantages();if (decisionValues[Tree.CONTINUE] - rev.getCost2Continue() >=

469 decisionValues[Tree.IMPROVE] - rev.getCost2Improve()- rev.getCost2Continue()) {

ArrayList<TreeNode> nodesToDelete = iNode.getToNodesForDeletion(Tree.IMPROVE);

471 for (TreeNode delNode : nodesToDelete) { //also removethe from connections of the nodes connected after thenode for deletion !!!!ArrayList<Connection> consToDelete = delNode.

getConnectionsTo();473 for (Connection c : consToDelete) {

c.getToNode().getConnectionsFrom().remove(c);475 }

}477 allNodes.removeAll(nodesToDelete);

iNode.removeOption(Tree.IMPROVE);479 if (decisionValues[Tree.CONTINUE] - rev.getCost2Continue()

>= 0 || !this.includeAbandon) {iNode.setValue(decisionValues[Tree.CONTINUE]);

481 iNode.setDecision(Tree.CONTINUE);}

483 else {iNode.setValue(0);

485 iNode.setDecision(Tree.ABANDON);nodesToDelete = iNode.getToNodesForDeletion(Tree.CONTINUE);

487 for (TreeNode delNode : nodesToDelete) { //also removethe from connections of the nodes connected after thenode for deletion !!!!

81


ArrayList<Connection> consToDelete = delNode.getConnectionsTo();

489 for (Connection c : consToDelete) {c.getToNode().getConnectionsFrom().remove(c);

491 }}

493 allNodes.removeAll(nodesToDelete);iNode.removeOption(Tree.CONTINUE);

495 }

497 }else {

499 ArrayList<TreeNode> nodesToDelete = iNode.getToNodesForDeletion(Tree.CONTINUE);

for (TreeNode delNode : nodesToDelete) { //also remove thefrom connections of the nodes connected after the node fordeletion !!!!

501 ArrayList<Connection> consToDelete = delNode.getConnectionsTo();

for (Connection c : consToDelete) {503 c.getToNode().getConnectionsFrom().remove(c);

}505 }

allNodes.removeAll(nodesToDelete);507 iNode.removeOption(Tree.CONTINUE);

if (decisionValues[Tree.IMPROVE] - rev.getCost2Continue() >= 0|| !this.includeAbandon) {

509 iNode.setValue(decisionValues[Tree.IMPROVE]);iNode.setDecision(Tree.IMPROVE);

511 }else {

513 iNode.setValue(0);iNode.setDecision(Tree.ABANDON);

515 nodesToDelete = iNode.getToNodesForDeletion(Tree.IMPROVE);for (TreeNode delNode : nodesToDelete) { //also remove

the from connections of the nodes connected after thenode for deletion !!!!

517 ArrayList<Connection> consToDelete = delNode.getConnectionsTo();

for (Connection c : consToDelete) {519 c.getToNode().getConnectionsFrom().remove(c);

}521 }

allNodes.removeAll(nodesToDelete);523 iNode.removeOption(Tree.IMPROVE);

}525

}527 }

}529 markDisconnectedPaths();

//now delete all endNodes that have 0 direct connections531 nodes = getNodesForReview(T);

lowestPerfNode = 0;533 for (TreeNode n : nodes) {

if (n.getConnectionsFrom().isEmpty()) { allNodes.remove(n); }535 }

//now find lowest node value to determine the size of the canvas later on537 for (TreeNode n: allNodes) {

if (n.modelPerformance < lowestPerfNode) {lowestPerfNode = (int)n.modelPerformance; }

539 }}

82


541 //</editor-fold>

543 //<editor-fold defaultstate="collapsed" desc="Visual representation">public void draw(Graphics g) {

545 for (TreeNode n : allNodes) {n.drawConnections(g,this.hideDisconnectedNodes);

547 n.drawNode(g,this.hideDisconnectedNodes);

549 }for (TreeNode n : allNodes) {

551 if (n.showDetails) { n.drawDetails(g,this.hideDisconnectedNodes);} //Showing notes is done in a separate loop to keep the notes on top ofhe connections

}553 }

555 public void showNotes(int X, int Y){Location xyNode;

557 for (TreeNode n : allNodes){xyNode = n.getLocation();

559 int xMin =xyNode.getX() - Tree.NODE_RADIUS;int xMax = xMin + 2*Tree.NODE_RADIUS;

561 int yMin = xyNode.getY() - Tree.NODE_RADIUS;int yMax = yMin + 2*Tree.NODE_RADIUS;

563 if (xMin<=X && xMax>=X && yMin<=Y && yMax>=Y) {n.showDetails = !n.showDetails;

565 break;}

567 }}

569

//</editor-fold>571

//<editor-fold defaultstate="collapsed" desc="Private methods">573 private ArrayList<TreeNode> getNodesForReview(int Time) {

ArrayList<TreeNode> returnNodes = new ArrayList<TreeNode>();575 for (TreeNode n : allNodes) {

if (n.getTime() == Time) {577 returnNodes.add(n);

}579 }

return returnNodes;581 }

583 private TreeNode getNode(int Time, double Performance) {TreeNode returnNode = null;

585 for (TreeNode n : allNodes) {if (n.getTime() == Time) {

587 if (n.getModelPerformance() == Performance) {returnNode = n;

589 }}

591 }return returnNode;

593 }

595 private void emptyTree() {allNodes.clear();

597 }

599 private void calcModelPerformances() {//this method calculates the modelperformances, given the estimated

performances

83


601 int nrOfEndnodes;nrOfEndnodes = 1;

603 for (int i = 0; i<T; i++) {nrOfEndnodes += allReviews.get(i).getNrOfNextStates()-1;

605 }//Given the fact that with continue, the tree is symmetrical we get

modelMax by following:607 modelPerformances[Tree.BEST_EXPECTED] = 0 + (nrOfEndnodes-1)/2;

modelPerformances[Tree.MOST_LIKELY] = 0;609 modelPerformances[Tree.WORST_EXPECTED] = 0 -(nrOfEndnodes-1)/2;

//now calculate the best possible performance on the model scale611 double bestModelPerf = modelPerformances[Tree.BEST_EXPECTED] +

(estimatedPerformances[Tree.BEST_POSSIBLE]-estimatedPerformances[Tree.BEST_EXPECTED]) *

613 modelPerformances[Tree.BEST_EXPECTED]/(estimatedPerformances[Tree.BEST_EXPECTED]-estimatedPerformances[Tree.MOST_LIKELY]);

modelPerformances[Tree.BEST_POSSIBLE] = Math.round(bestModelPerf*100)/100;615 }

617 private double calcPerformance(double ModelPerformance) {//this method returns the performance belonging to a certain model

performance619 double returnP;

double bestEstimate = this.estimatedPerformances[Tree.BEST_EXPECTED];621 double mostLikely = this.estimatedPerformances[Tree.MOST_LIKELY];

double worstEstimate = this.estimatedPerformances[Tree.WORST_EXPECTED];623 double bestModel = this.modelPerformances[Tree.BEST_EXPECTED];

double worstModel = this.modelPerformances[Tree.WORST_EXPECTED];625 if (ModelPerformance >= 0) {

returnP = ModelPerformance* (bestEstimate-mostLikely)/bestModel +mostLikely;

627 }else {

629 returnP = ModelPerformance* (worstEstimate-mostLikely)/(worstModel) +mostLikely;

}631 return returnP;

}633

private void markDisconnectedPaths() { //all nodes that do not go back to thefirst node, are disconnected and should be marked

635 for (int t=1; t<=T; t++) { //start with review 1 (not 0) and endWITH the endnodesArrayList<TreeNode> nodesForRevT = getNodesForReview(t);

637 for (TreeNode n : nodesForRevT) {ArrayList<Connection> cons = n.getConnectionsFrom();

639 if (cons == null) {n.setConnected(false);

641 }else if (cons.isEmpty()) {

643 n.setConnected(false);}

645 else {boolean connected = false; //standard is false, but if one

of the from nodes is connected, this node is also connected647 for (Connection c : cons) {

if (c.getFromNode().isConnected()) {649 connected = true;

}651 }

n.setConnected(connected);653 }

}

84


655 }}

657

private static String getTagValue(String sTag, Element eElement) {659 NodeList nlList = eElement.getElementsByTagName(sTag).item(0).getChildNodes();

Node nValue = (Node) nlList.item(0);661 return nValue.getNodeValue();

}663 //</editor-fold>

}

E.5 TreeNode.java


import java.awt.*;4 import java.util.ArrayList;/**

6 ** @author Mathijs van Suilichem

8 */

10 public abstract class TreeNode {

12 private static int idCounter; //@todo eventually, ID should no longerbe necessary

private int ID;14 int t;

protected double modelPerformance; //performanceValue without unit16 protected double expectedPerformance; //performanceValue with unit, e.g. %

Yieldprotected double value; //economic value

18 protected ArrayList<Connection> connectionsTo;protected ArrayList<Connection> connectionsFrom;

20 public boolean showDetails;protected boolean connected;

22 Location myLocation;

24 public TreeNode(int Time , double PerformanceValue) { //NB maxPer needs to bein the models scale!!!!!!this.ID = idCounter++; //give unique id and increase counter

26 this.modelPerformance = PerformanceValue;this.t = Time;

28 this.showDetails = false;connectionsTo = new ArrayList<Connection>();

30 connectionsFrom = new ArrayList<Connection>();}

32

34 //<editor-fold defaultstate="collapsed" desc="Getters and Setters">public void setLocation(int x,int y) {

36 myLocation = new Location(x,y);}

38 public Location getLocation() {return myLocation;

40 }public int getTime() {

42 return this.t;}

44 public double getModelPerformance() {return this.modelPerformance;

46 }public double getExpectedPerformance() {

85


48 return this.expectedPerformance;}

50 public double getvalue() {return this.value;

52 }public void setValue(double Value) {

54 this.value = Value;}

56 public ArrayList<Connection> getConnectionsTo() {return this.connectionsTo;

58 }public ArrayList<Connection> getConnectionsFrom() {

60 return this.connectionsFrom;}

62 public boolean isConnected() {return this.connected;

64 }public void setConnected(boolean Connected) {

66 this.connected = Connected;}

68 public int getID() {return this.ID;


72

public abstract void drawNode(Graphics g, boolean HideDisconnected);74

public abstract void drawConnections(Graphics g, boolean HideDisconnected);76

public abstract void drawDetails(Graphics g, boolean HideDisconnected);78

}

E.6 EndNode.java

1 package npd_supplychain_strategist;import java.awt.*;

3 /***


*/7 public class EndNode extends TreeNode{

9 private int nodeHeight;private int nodeWidth;

11 private Font font = new Font("Sans-serif", Font.BOLD, 16);private int radius;

13

public EndNode(int Time, double Performance) {15 super(Time,Performance);

this.nodeHeight = 2 * Tree.NODE_RADIUS;17 this.nodeWidth = 15 * Tree.NODE_RADIUS;

this.radius = Tree.NODE_RADIUS;19 }

21 public void drawNode(Graphics g, boolean HideDisconnected) {if (connected || !HideDisconnected) {

23 g.setColor(Color.black);g.fillRect(myLocation.getX(), (int)(myLocation.getY()-0.5*nodeHeight),

nodeWidth, nodeHeight);25 g.setColor(Color.WHITE);

g.setFont(font);

86


27 g.drawString(Tree.roundPerformance(this.expectedPerformance,2) + " |" + Tree.roundFinance(this.value,0),

myLocation.getX()+Tree.NODE_RADIUS, myLocation.getY()+5);29

}31 }

33 public void drawConnections(Graphics g, boolean HideDisconnected) {}

35

public void drawDetails(Graphics g, boolean HideDisconnected) {37 if (connected || !HideDisconnected) {

int noteWidth = 260;39 int noteHeight = 25;

int noteXspace = 7;41 int noteYspace = 5;

int noteXgap = 50;43 g.setColor(Color.yellow);

g.fillRect(myLocation.getX()+nodeWidth+noteXgap,myLocation.getY()-nodeHeight-noteHeight, noteWidth, noteHeight); //fill

45 g.setColor(Color.black);g.drawRect(myLocation.getX()+nodeWidth+noteXgap,myLocation.getY()-

nodeHeight-noteHeight, noteWidth, noteHeight); //border47 g.drawLine(myLocation.getX()+nodeWidth,myLocation.getY(),myLocation.

getX()+nodeWidth+noteXgap,myLocation.getY()-nodeHeight); //Line tonote -> Endnode is overwritten!

drawNode(g,HideDisconnected);

//Redraw IntermediateNode becuase otherwise Line is throughIntermediateNode

49 g.setColor(Color.black);//g.drawString("Perf: ", myLocation.getX()+2*nodeWidth+2+noteXspace,

myLocation.getY()-2*nodeWidth-noteYspace-3*noteLignSpace);51 //g.drawString(" " + Tree.roundPerformance(this.expectedPerformance,2)

, myLocation.getX()+2*nodeWidth+2+noteXspace, myLocation.getY()-2*nodeWidth-noteYspace-2*noteLignSpace);

//g.drawString("Value: ", myLocation.getX()+2*nodeWidth+2+noteXspace,myLocation.getY()-2*nodeWidth-noteYspace-noteLignSpace);

53 //g.drawString(" " + Tree.roundFinance(this.value,0),myLocation.getX()+2*nodeWidth+2+noteXspace, myLocation.getY()-2*nodeWidth-2 -noteYspace);

g.drawString("Detailed performance: " + Tree.roundPerformance(this.expectedPerformance,6),

55 myLocation.getX()+nodeWidth+noteXgap+noteXspace, myLocation.getY()-nodeHeight-noteYspace);

}57 }

}

E.7 IntermediateNode.java

package npd_supplychain_strategist;2 import java.awt.*;import java.util.ArrayList;

4 /***


*/8

public class IntermediateNode extends TreeNode {10

private double p[];12 private int n; //nr of next states

87


private double improveAmount;14 private int radius;

private byte decision;16 private double maxPerformance;

private double discountRate;18

public IntermediateNode(int Time , double PerformanceValue, int NrOfNextStates,double Chances[], double ImprovePercentage, double maxPer) { //NB maxPer

needs to be in the models scale!!!!!!20 super(Time,PerformanceValue); //first intialize the super, in this case "

TreeNode"this.p = Chances;

22 this.n = NrOfNextStates;this.maxPerformance = maxPer;

24 //keep option open to use the fixed improvement amount from the model byHuchzermeier and Loch => if ImprovePercentage=0

if (ImprovePercentage >1) {26 this.improveAmount = 1; //attention, our model has raster 0.5

instead of raster 1 as in Huchzermeier and Loch!}

28 else {this.improveAmount = ImprovePercentage * (maxPer - modelPerformance);

//NB maxPer needs to be in the models scale!!!!!!30 }

this.radius = Tree.NODE_RADIUS;32 connectionsTo = new ArrayList<Connection>();

for (int i=0; i<NrOfNextStates; i++) {34 connectionsTo.add(new Connection(this,Tree.CONTINUE,p[i],

getNextPerformance(i,Tree.CONTINUE)));connectionsTo.add(new Connection(this,Tree.IMPROVE,p[i],

getNextPerformance(i,Tree.IMPROVE)));36 //create both a continue and an improve connection.

}38 this.connected = false;

DecisionTree dTree = DecisionTree.getInstance();40 this.discountRate = dTree.getDiscountRate();

}42

//<editor-fold defaultstate="collapsed" desc="Getters and Setters">44 public int getN() {

return n;46 }

public byte getDecision() {48 return decision;

}50 public void setDecision(byte Decision){

this.decision = Decision;52 }

//</editor-fold>54

public void removeOption(byte option) {56 ArrayList<Connection> removeCons = new ArrayList<Connection>();

TreeNode node;58 for (Connection c : connectionsTo) {

if (c.getType() == option) {60 if (c.getToNode() instanceof IntermediateNode) {

node = (IntermediateNode)(c.getToNode());62 }

else {64 node = (EndNode)(c.getToNode());

}66 node.connectionsFrom.remove(c); //remove not only the

connection, but also the link from next node to this connection

88


removeCons.add(c);68 }

}70 connectionsTo.removeAll(removeCons);

}72

public ArrayList<TreeNode> getToNodesForDeletion(byte Option) {74 ArrayList<TreeNode> returnNodes = new ArrayList<TreeNode>();

for (Connection c : connectionsTo) {76 if (c.getType() == Option) {

if (c.getToNode().getConnectionsFrom().size() == 1) { //only addfor deletion if the to TreeNode has only this connection and noothers!

78 returnNodes.add(c.getToNode());}

80 }}

82 return returnNodes;}

84

public double[] getDecisionAdvantages() { //return an array of length 2with the values for the decision Continue and improve

86 double[] values = {0.0,0.0};for (Connection c : connectionsTo) {

88 if (c.getType() == Tree.CONTINUE) {values[Tree.CONTINUE] += (c.chance * c.getToNode().getvalue());

90 }else {

92 values[Tree.IMPROVE] += (c.chance * c.getToNode().getvalue());}

94 }//Now we need to correct for the discount rate for both options

96 values[Tree.CONTINUE] /= (1+discountRate);values[Tree.IMPROVE] /= (1+discountRate);

98 return values;}

100 //<editor-fold defaultstate="collapsed" desc="Drawing">public void drawNode(Graphics g, boolean HideDisconnected) {

102 int outlineAmount=0;if (connected || !HideDisconnected) {

104 Font font = new Font("Sans-serif", Font.BOLD, 16);String dec = "tempvalue";

106 if (decision == Tree.IMPROVE) {g.setColor(Color.GREEN);

108 dec = "I";outlineAmount = 2;

110 }else if (decision == Tree.CONTINUE) {

112 g.setColor(Color.BLUE);dec = "C";

114 outlineAmount = 5;}

116 else if (decision == Tree.ABANDON) {g.setColor(Color.RED);

118 dec = "A";outlineAmount = 5;

120 }g.fillOval(myLocation.getX()-radius,myLocation.getY()-radius,2*radius

,2*radius);122 g.setColor(Color.WHITE);

g.setFont(font);124 g.drawString(dec,myLocation.getX()-outlineAmount, myLocation.getY()+6);

}

89


126 }

128 public void drawConnections(Graphics g, boolean HideDisconnected) {if (connected || !HideDisconnected) {

130 g.setColor(Color.BLUE);for (Connection c: this.connectionsTo) {

132 int yDistance = (int)((c.getNextPerformanceValue()-this.getModelPerformance())*Tree.VECTOR_Y);

g.drawLine(myLocation.getX(),myLocation.getY(),myLocation.getX()+Tree.VECTOR_X,myLocation.getY()-yDistance);

134 }}

136 }

138 public void drawDetails(Graphics g, boolean HideDisconnected) {if (connected || !HideDisconnected) {

140 int noteWidth = 160;int noteHeight = 45;

142 int noteXspace = 5;int noteYspace = 5;

144 int noteLignSpace = 20;g.setColor(Color.yellow);

146 g.fillRect(myLocation.getX()+2*radius,myLocation.getY()-2*radius-noteHeight, noteWidth, noteHeight); //fill

g.setColor(Color.black);148 g.drawRect(myLocation.getX()+2*radius,myLocation.getY()-2*radius-

noteHeight, noteWidth, noteHeight); //borderg.drawLine(myLocation.getX(),myLocation.getY(),myLocation.getX()+2*

radius,myLocation.getY()-2*radius); //Line to note ->IntermediateNode is overwritten!

150 g.drawArc(myLocation.getX(), myLocation.getY(),(int)0.5*noteWidth,(int)0.5*noteHeight, -90, 90);

drawNode(g,HideDisconnected);

//Redraw IntermediateNode becuase otherwise Line is throughIntermediateNode

152 g.setColor(Color.black);g.drawString("Perf: " + Tree.roundPerformance(this.expectedPerformance

,4),154 myLocation.getX()+2*radius+2+noteXspace, myLocation.getY()

-2*radius-noteYspace-noteLignSpace);g.drawString("Value: " + Tree.roundFinance(this.value,0),myLocation.

getX()+2*radius+2+noteXspace, myLocation.getY()-2*radius-2 -noteYspace);

156 }}

158

//</editor-fold>160

private double getNextPerformance(int Nr, byte Type) { //returns next modelperformance

162 double lowestPerf = modelPerformance - 0.5*(n-1);if (Type == Tree.IMPROVE) {

164 lowestPerf += improveAmount;}

166 return (lowestPerf + Nr <= this.maxPerformance)?lowestPerf + Nr:this.maxPerformance; //return no more then the maxPerformance possible

}168

}

E.8 Location.java

90


1 package npd_supplychain_strategist;

3 /***


*/7 public class Location {

private int x,y;9

public Location(int x, int y) {11 this.x = x;

this.y = y;13 }

15 public int getX() {return x;

17 }

19 public int getY() {return y;

21 }}

E.9 NetworkCanvas.java

package npd_supplychain_strategist;2 import java.awt.*;import javax.swing.*;

4 import java.awt.event.*;import java.awt.print.*;

6 /***


*/10 public class NetworkCanvas extends JPanel implements Printable{

12 private DecisionTree dTree;private JFrame repainter;

14

public NetworkCanvas() {16 this.setAutoscrolls(true);

//this.setPreferredSize(new Dimension(20000,16000));18 this.addMouseListener(new MouseClicked());

}20

public void registerForRepaintRequest(JFrame frame){22 this.repainter = frame;

}24

@Override26 public void paintComponent(Graphics g) {

g.setColor(Color.white);28 g.fillRect(0,0,this.getWidth(),this.getHeight());

if (DecisionTree.exists()) {30 //Draw Tree with nodes

dTree = DecisionTree.getInstance();32 if (dTree.isBuilt()) { this.setPreferredSize(dTree.getDimension());

}this.revalidate();

34 dTree.draw(g);}

36 }

91


38 public int print(Graphics g, PageFormat pf, int pi) throws PrinterException{if (pi>=1) {

40 return Printable.NO_SUCH_PAGE;}

42

Graphics2D g2 = (Graphics2D) g;44 g2.translate(pf.getImageableX(), pf.getImageableY());

Font f = new Font("Monospaced",Font.PLAIN,12);46 g2.setFont(f);

paint(g2);48 return Printable.PAGE_EXISTS;

}50

class MouseClicked implements MouseListener {52 public void mouseExited(MouseEvent event){

54 }public void mouseEntered(MouseEvent event){

56

}58 public void mouseReleased(MouseEvent event){

60 }public void mousePressed(MouseEvent event){

62

}64 public void mouseClicked(MouseEvent event){

if (event.getButton() == MouseEvent.BUTTON1 && DecisionTree.exists()) {//first check whether it was a left click and tree exists!

66 dTree = DecisionTree.getInstance();int x = event.getX();

68 int y = event.getY();dTree.showNotes(x, y);

70 repainter.repaint();}

72

}74 }

}

E.10 ProjectPanel.java

1 package npd_supplychain_strategist;import java.awt.*;

3 import java.awt.event.*;import javax.swing.*;

5 import javax.swing.BorderFactory.*;import java.text.*;

7 import java.beans.PropertyChangeListener;import java.beans.PropertyChangeEvent;

9 /***


*/13 public class ProjectPanel extends JPanel{

15 private JFrame repainter; //to get a reference to the frame and command it torefresh

private GridBagConstraints gbc;17

public void registerForFrameChanges(JFrame frame) {19 this.repainter = frame;

}

92


21

public void emptyValues() {23 CoG = 0;

nrOfProductsPerYear = 0;25 nrOfYearsToReturn = 0;

target = 0;27 bestExpected = 0;

bestPossible = 0;29 discount = 0;

mostLikely = 0;31 nrOfReviews = 0;

worstExpected = 0;33 this.txtCoG.setValue(null);

this.txtNrOfProductsPerYear.setValue(null);35 this.txtNrOfYearsToReturn.setValue(null);

this.txtTarget.setValue(null);37 this.txtbestExpected.setValue(null);

this.txtbestPossible.setValue(null);39 this.txtdiscount.setValue(null);

this.txtmostLikely.setValue(null);41 this.txtnrOfReviews.setValue(null);

this.txtworstExpected.setValue(null);43 this.cmdCalc.setEnabled(false);

this.chkHideUnreachableStates.setSelected(false);45 this.chkIncludeAbandonOption.setSelected(false);

47 }

49 //<editor-fold defaultstate="collapsed" desc="Local variable declarations">private DecisionTree dTree;

51 private JButton cmdCalc = new JButton("Calculate and draw Tree");private JButton cmdCreate = new JButton("Create Project");

53 private JCheckBox chkHideUnreachableStates = new JCheckBox("Hide unreachableStates");

private JCheckBox chkIncludeAbandonOption = new JCheckBox("Include AbandonOption");

55 private JButton cmdZoomInY = new JButton("Y +");private JButton cmdZoomOutY = new JButton("Y -");

57 private JButton cmdZoomInX = new JButton("X +");private JButton cmdZoomOutX = new JButton("X -");

59

//Parameters for the project61 private double discount;

private int nrOfReviews;63 private double worstExpected;

private double mostLikely;65 private double bestExpected;

private double bestPossible;67 private double target;

private double CoG; //needed to calculate impact69 private int nrOfProductsPerYear; //needed to calculate impact

private int nrOfYearsToReturn; //needed to calculate financial impct (nr of years after which the break even point is)

71 private boolean includeAbandon;

73 //Textfieldsprivate JFormattedTextField txtdiscount;

75 private JFormattedTextField txtnrOfReviews;private JFormattedTextField txtworstExpected;

77 private JFormattedTextField txtmostLikely;private JFormattedTextField txtbestExpected;

79 private JFormattedTextField txtbestPossible;private JFormattedTextField txtTarget;

93


81 private JFormattedTextField txtCoG;private JFormattedTextField txtNrOfProductsPerYear;

83 private JFormattedTextField txtNrOfYearsToReturn;//Labels

85 private JLabel lblDiscount = new JLabel("Discount rate",JLabel.RIGHT);private JLabel lblNrOfReviews = new JLabel("Reviews [#]",JLabel.RIGHT);

87 private JLabel lblWorstExpected = new JLabel("Worst Expected",JLabel.RIGHT);private JLabel lblMostLikely = new JLabel("Most Likely",JLabel.RIGHT);

89 private JLabel lblBestExpected = new JLabel("Best Expected",JLabel.RIGHT);private JLabel lblBestPossible = new JLabel("Best Possible",JLabel.RIGHT);

91 private JLabel lblTarget = new JLabel("Target",JLabel.RIGHT);private JLabel lblCoG = new JLabel("Cost of Goods",JLabel.RIGHT);

93 private JLabel lblNrOfProductsPerYear = new JLabel("Products / year [#]",JLabel.RIGHT);

private JLabel lblNrOfYearsToReturn = new JLabel("Payback period [yr]",JLabel.RIGHT);

95

//Formats to format and parse numbers97 private NumberFormat percentageFormat;

private NumberFormat amountFormat;99 private NumberFormat performanceFormat;

private NumberFormat costFormat;101 //</editor-fold>

103 //<editor-fold defaultstate="collapsed" desc="Constructor">public ProjectPanel() {

105

this.setLayout(new FlowLayout(FlowLayout.LEFT));107 JPanel container = new JPanel(new GridBagLayout());

gbc = new GridBagConstraints ();109 //Create the text fields and set them up.

txtdiscount = new JFormattedTextField(percentageFormat);111 txtdiscount.addPropertyChangeListener("value",new textListener());

txtdiscount.setColumns(5);113

txtnrOfReviews = new JFormattedTextField(amountFormat);115 //txtnrOfReviewsField.addActionListener(new textListener2());

txtnrOfReviews.addPropertyChangeListener("value",new textListener());117 txtnrOfReviews.setColumns(5);

119 txtworstExpected = new JFormattedTextField(performanceFormat);txtworstExpected.addPropertyChangeListener("value",new textListener());

121 txtworstExpected.setColumns(5);

123 txtmostLikely = new JFormattedTextField(performanceFormat);txtmostLikely.addPropertyChangeListener("value",new textListener());

125 txtmostLikely.setColumns(5);

127 txtbestExpected = new JFormattedTextField(performanceFormat);txtbestExpected.addPropertyChangeListener("value",new textListener());

129 txtbestExpected.setColumns(5);

131 txtbestPossible = new JFormattedTextField(performanceFormat);txtbestPossible.addPropertyChangeListener("value",new textListener());

133 txtbestPossible.setColumns(5);

135 txtTarget = new JFormattedTextField(performanceFormat);txtTarget.addPropertyChangeListener("value", new textListener());

137 txtTarget.setColumns(5);

139 txtCoG = new JFormattedTextField(costFormat);txtCoG.addPropertyChangeListener("value",new textListener());

141 txtCoG.setColumns(5);

94


143 txtNrOfProductsPerYear = new JFormattedTextField(amountFormat);txtNrOfProductsPerYear.addPropertyChangeListener("value",new textListener()

);145 txtNrOfProductsPerYear.setColumns(5);

147 txtNrOfYearsToReturn = new JFormattedTextField(amountFormat);txtNrOfYearsToReturn.addPropertyChangeListener("value",new textListener());

149 txtNrOfYearsToReturn.setColumns(5);

151 //Add the labels and textfields to a panel.JPanel p1 = new JPanel(new GridBagLayout());

153 gbc = new GridBagConstraints ();gbc.insets = new Insets(3,2,3,3); //Space between components

155 gbc.anchor = GridBagConstraints.EAST;//Column 1

157 gbc.gridx = 0;gbc.gridy = 0;

159 gbc.gridwidth = 1;p1.add(lblNrOfReviews,gbc);

161 gbc.gridy = 1;p1.add(lblDiscount,gbc);

163 //Column 2gbc.gridx = 1;

165 gbc.gridy = 0;p1.add(txtnrOfReviews,gbc);

167 gbc.gridy = 1;p1.add(txtdiscount,gbc);

169 //column 3gbc.gridx = 2;

171 gbc.gridy = 0;p1.add(lblWorstExpected,gbc);

173 gbc.gridy = 1;p1.add(lblMostLikely,gbc);

175 gbc.gridy = 2;p1.add(lblBestExpected,gbc);


179 gbc.gridy = 0;p1.add(txtworstExpected,gbc);

181 gbc.gridy = 1;p1.add(txtmostLikely,gbc);

183 gbc.gridy = 2;p1.add(txtbestExpected,gbc);

185 // column 5gbc.gridx = 4;

187 gbc.gridy = 0;p1.add(lblBestPossible,gbc);

189 gbc.gridy = 1;p1.add(lblTarget,gbc);


193 gbc.gridy = 0;p1.add(txtbestPossible,gbc);

195 gbc.gridy = 1;p1.add(txtTarget,gbc);

197 //column 7gbc.gridx = 6;

199 gbc.gridy = 0;p1.add(lblCoG,gbc);

201 gbc.gridy = 1;p1.add(lblNrOfProductsPerYear,gbc);

203 gbc.gridy = 2;

95


p1.add(lblNrOfYearsToReturn,gbc);205 //column 8

gbc.gridx = 7;207 gbc.gridy = 0;

p1.add(txtCoG,gbc);209 gbc.gridy = 1;

p1.add(txtNrOfProductsPerYear,gbc);211 gbc.gridy = 2;

p1.add(txtNrOfYearsToReturn,gbc);213

// now add the buttons to a second panel215 JPanel p2 = new JPanel(new GridBagLayout());

cmdCreate.addActionListener(new buttonListener());217 cmdCalc.addActionListener(new buttonListener());

cmdCalc.setEnabled(false);219 //cmdCalc is widest so let others take its width

cmdCreate.setPreferredSize(cmdCalc.getPreferredSize());221 gbc.gridx = 0;

gbc.gridy = 0;223 p2.add(cmdCreate,gbc);

gbc.gridy = 1;225 p2.add(cmdCalc,gbc);

//Now create a panel for the checkboxes227 JPanel p3 = new JPanel(new GridBagLayout());

chkHideUnreachableStates.addItemListener(new checkBoxListener());229 chkIncludeAbandonOption.addItemListener(new checkBoxListener());

chkHideUnreachableStates.setSelected(false);231 chkIncludeAbandonOption.setSelected(false);

chkIncludeAbandonOption.setPreferredSize(chkHideUnreachableStates.getPreferredSize());


235 p3.add(chkHideUnreachableStates,gbc);gbc.gridy = 1;

237 p3.add(chkIncludeAbandonOption,gbc);//now create a zoom panel

239 //adjust widthsJPanel p4 = new JPanel(new GridBagLayout());

241 cmdZoomOutX.setPreferredSize(cmdZoomInX.getPreferredSize());cmdZoomOutY.setPreferredSize(cmdZoomInX.getPreferredSize());

243 //add actionhandlerscmdZoomInY.addActionListener(new buttonListener());

245 cmdZoomOutY.addActionListener(new buttonListener());cmdZoomInX.addActionListener(new buttonListener());

247 cmdZoomOutX.addActionListener(new buttonListener());//column 1


251 p4.add(cmdZoomInX,gbc);gbc.gridy = 1;

253 p4.add(cmdZoomOutX,gbc);//column 2


257 p4.add(cmdZoomInY,gbc);gbc.gridy = 1;

259 p4.add(cmdZoomOutY,gbc);gbc.insets = new Insets(5,10,5,10); //Different spacing between panels

opposed to components (top,left,bottom, right)261 gbc.anchor = GridBagConstraints.FIRST_LINE_START;


container.add(p1,gbc);

96


265 gbc.gridx= 1 ;container.add(p2,gbc);

267 gbc.gridx = 2;container.add(p3,gbc);

269 gbc.gridx = 3;container.add(p4,gbc);

271 this.setBorder(BorderFactory.createEtchedBorder());this.add(container);


275


super.paintComponent(g);279 dTree = DecisionTree.getInstance(); //try to give values if e.g. a file

was openedif (dTree != null) {

281 txtdiscount.setValue(Double.toString(dTree.getDiscountRate()));txtnrOfReviews.setValue(Integer.toString(dTree.getNrOfReviews()));

283 txtworstExpected.setValue(Double.toString(dTree.getEstimatedPerformance(Tree.WORST_EXPECTED)));

txtmostLikely.setValue(Double.toString(dTree.getEstimatedPerformance(Tree.MOST_LIKELY)));

285 txtbestExpected.setValue(Double.toString(dTree.getEstimatedPerformance(Tree.BEST_EXPECTED)));

txtbestPossible.setValue(Double.toString(dTree.getEstimatedPerformance(Tree.BEST_POSSIBLE)));

287 txtTarget.setValue(Double.toString(dTree.getTargetPerformance()));txtCoG.setValue(Double.toString(dTree.getCoG()));

289 txtNrOfProductsPerYear.setValue(Integer.toString(dTree.getNrOfProductsPerYear()));

txtNrOfYearsToReturn.setValue(Integer.toString(dTree.getNrOfYearsPayback()));

291 cmdCalc.setEnabled(true);}

293 }

295 class buttonListener implements ActionListener {public void actionPerformed(ActionEvent event) {

297 if (event.getSource() == cmdCreate) {cmdCreateClicked();

299 }else if (event.getSource() == cmdCalc) {

301 cmdCalcClicked();}

303 else if (event.getSource() == cmdZoomInY) {Tree.stretchY();


307 else if (event.getSource() == cmdZoomInX) {Tree.stretchX();


311 else if (event.getSource() == cmdZoomOutY) {Tree.crimpY();


315 else if (event.getSource() == cmdZoomOutX) {Tree.crimpX();


319 }}

97


321

class textListener implements PropertyChangeListener {323 public void propertyChange(PropertyChangeEvent e) {

Object source = e.getSource();325 if (source == txtdiscount && txtdiscount.getValue() != null) {

discount = Double.parseDouble((String)txtdiscount.getValue());327 }

else if (source == txtnrOfReviews && txtnrOfReviews.getValue() != null){

329 nrOfReviews = Integer.parseInt((String)txtnrOfReviews.getValue());}

331 else if (source == txtworstExpected && txtworstExpected.getValue() !=null) {worstExpected = Double.parseDouble((String)txtworstExpected.

getValue());333 }

else if (source == txtmostLikely && txtmostLikely.getValue() != null) {335 mostLikely = Double.parseDouble((String)txtmostLikely.getValue());

}337 else if (source == txtbestExpected && txtbestExpected.getValue() !=

null) {bestExpected = Double.parseDouble((String)txtbestExpected.getValue

());339 }

else if (source == txtbestPossible && txtbestPossible.getValue() !=null) {

341 bestPossible = Double.parseDouble((String)txtbestPossible.getValue());

}343 else if (source == txtTarget && txtTarget.getValue() != null) {

target = Double.parseDouble((String)txtTarget.getValue());345 }

else if (source == txtCoG && txtCoG.getValue() != null) {347 CoG = Double.parseDouble((String)txtCoG.getValue());

}349 else if (source == txtNrOfProductsPerYear && txtNrOfProductsPerYear.

getValue() != null) {nrOfProductsPerYear = Integer.parseInt((String)

txtNrOfProductsPerYear.getValue());351 }

else if (source == txtNrOfYearsToReturn && txtNrOfYearsToReturn.getValue() != null) {

353 nrOfYearsToReturn = Integer.parseInt((String)txtNrOfYearsToReturn.getValue());

}355 }

}357

class checkBoxListener implements ItemListener {359

public void itemStateChanged(ItemEvent e) {361 Object source = e.getItemSelectable();

if (source == chkHideUnreachableStates) {363 setStateHideDisconnected(chkHideUnreachableStates.isSelected());

}365 else if (source == chkIncludeAbandonOption) {

includeAbandon = chkIncludeAbandonOption.isSelected();367 if (DecisionTree.exists()) {

DecisionTree dTree = DecisionTree.getInstance();369 dTree.setEnableAbandon(includeAbandon);

371 }}

98


373 }}

375

private void cmdCreateClicked() {377 //This method creates the initial tree and thus the reviewpanel can be

drawm with the right amount of reviews.if (nrOfReviews > 0) {

379 dTree = DecisionTree.getInstance(nrOfReviews); //create tree withdecision points

cmdCalc.setEnabled(true);381 //now try to fill the variables that are known already

if (bestPossible > 0) {383 dTree.setEstimatedPerformance(bestPossible, Tree.BEST_POSSIBLE);

}385 if (worstExpected > 0) {

dTree.setEstimatedPerformance(worstExpected, Tree.WORST_EXPECTED);387 }

if (mostLikely > 0) {389 dTree.setEstimatedPerformance(mostLikely, Tree.MOST_LIKELY);

}391 if (bestExpected > 0) {

dTree.setEstimatedPerformance(bestExpected,Tree.BEST_EXPECTED);393 }

if (target > 0) {395 dTree.setTargetPerformance(target);

}397 if (discount > 0) {

dTree.setDiscountRate(discount);399 }

if (CoG > 0) {401 dTree.setCoG(CoG);

}403 if (nrOfProductsPerYear > 0) {

dTree.setNrOfProductsPerYear(nrOfProductsPerYear);405 }

if (nrOfYearsToReturn > 0) {407 dTree.setNrOfYearsPayback(nrOfYearsToReturn);

}409 repainter.repaint();

}411 }

413 private void cmdCalcClicked() {if (bestPossible > 0 && worstExpected > 0 && mostLikely > 0 && bestExpected

> 0 && target > 0 && discount>0415 && CoG > 0 && nrOfProductsPerYear >0 && nrOfYearsToReturn > 0) {

dTree = DecisionTree.getInstance();417 dTree.setEstimatedPerformance(bestPossible, Tree.BEST_POSSIBLE);

dTree.setEstimatedPerformance(worstExpected, Tree.WORST_EXPECTED);419 dTree.setEstimatedPerformance(mostLikely, Tree.MOST_LIKELY);

dTree.setEstimatedPerformance(bestExpected,Tree.BEST_EXPECTED);421 dTree.setTargetPerformance(target);

dTree.setDiscountRate(discount);423 dTree.setCoG(CoG);

dTree.setNrOfProductsPerYear(nrOfProductsPerYear);425 dTree.setNrOfYearsPayback(nrOfYearsToReturn);

if (this.chkHideUnreachableStates.isSelected()) {427 dTree.hideUnreachableStates(true);

}429 else {

dTree.hideUnreachableStates(false);431 }

dTree.buildTree();

99


433 dTree.calculateTree(new YieldCalculator(CoG,nrOfProductsPerYear,nrOfYearsToReturn,target));

//@todo this can be expanded for usage with other things besides yield.You need then to create a new class that imploements

ValueCalculator435 repainter.repaint();

}437 else {

String errorMsg = "One of the following fields was left blank:" + "\nDiscount rate" +

439 "\nWorst Expected" + "\nMost Likely" + "\nBest Expected" + "\nBest Possible" +

"\nTarget" + "\nCost of Goods" + "\nNr of Products per year" +"\nNr of Years for return";

441 JOptionPane.showMessageDialog(null,errorMsg);}

443 }

445 private void setStateHideDisconnected(boolean Hide) {if (DecisionTree.exists()) {

447 dTree = DecisionTree.getInstance();dTree.hideUnreachableStates(Hide);


451 }

453 }

E.11 ReviewPanel.java

1 package npd_supplychain_strategist;import javax.swing.*;

3 import java.awt.*;import java.util.ArrayList;

5 import java.beans.PropertyChangeListener;import java.beans.PropertyChangeEvent;

7 import javax.swing.event.ChangeEvent;import javax.swing.event.ChangeListener;

9 /***


*/13 public class ReviewPanel extends JPanel{

15 JFrame repainter; //to get a reference to the frame and command it to refreshDecisionTree dTree;

17 String[] labels;private JPanel reviewColumns;

19 private GridBagConstraints gbc;int nrOfReviewColumns; //this keeps track the number of review columns in the

panel to compare with DecisionTree21 private boolean needsUpdate;

23 public void registerForRepaintRequest(JFrame frame){this.repainter = frame;

25 }

27 public ReviewPanel() {needsUpdate = false;

29 this.setAlignmentX(Component.LEFT_ALIGNMENT);this.setLayout(new FlowLayout(FlowLayout.LEFT));

31 reviewColumns = new JPanel();

100


reviewColumns.setLayout(new GridBagLayout()); //BoxLayout(reviewColumns,BoxLayout.X_AXIS)); //NB this will be changed to GridLayout !!!!

33 gbc = new GridBagConstraints ();nrOfReviewColumns=0; //first time only, set the number of review columns

to zero.35 initLabelCol();

add(reviewColumns);37 }

39 private void initLabelCol() {//Create a panel with the labels and put it in place

41 labels = new String[] {"Review t=","Cost to Continue","Cost to Improve","Improvement Percentage","Nr of Next possible states","Chances"};

JPanel labelPanel = new JPanel();43 labelPanel.setLayout(new BoxLayout(labelPanel,BoxLayout.Y_AXIS));

int strut = 2; //this takes care that the first time, strut is a littlesmaller, leading to better alignment with the textfields

45 for (String s : labels) {JLabel l = new JLabel(s,JLabel.RIGHT);

47 l.setBorder(BorderFactory.createEmptyBorder(2,2,2,2));l.setAlignmentX(Component.RIGHT_ALIGNMENT);

49 l.setAlignmentY(Component.TOP_ALIGNMENT);labelPanel.add(l);

51 labelPanel.add(Box.createVerticalStrut(strut));strut = 5; //this takes care that the first time, strut is a little

smaller, leading to better alignment with the textfields53 }


gbc.gridwidth = 3;57 gbc.anchor = GridBagConstraints.FIRST_LINE_END; //make sure this box stays

in the upper right of the first cellreviewColumns.add(labelPanel,gbc);

59 }

61 private void initReviewColumns() {dTree = DecisionTree.getInstance();

63 if (dTree != null) {int dTreeN = dTree.getNrOfReviews();

65 for (int i=0; i<dTreeN; i++) {ArrayList<JComponent> reviewSpecifics = dTree.allReviews.get(i).

getFields(); //retreive arrayList with fields for t=i67 Box box = Box.createVerticalBox();

if (i==0) { //create some room between the labels and the first reviewfields

69 box.add(Box.createHorizontalStrut(10));}

71 for (JComponent f : reviewSpecifics) { //iterate to addtextfields to panelf.setAlignmentX(LEFT_ALIGNMENT);

73 if (f instanceof JLabel) {box.add(Box.createVerticalStrut(2)); //some room above the

label75 }

else if(f instanceof JTextField) {77 f.addPropertyChangeListener("value",new textListener());

}79 else if(f instanceof JSpinner) {

JSpinner js = (JSpinner)f;81 js.addChangeListener(new spinnerListener());

}83 box.add(f);

101


box.add(Box.createVerticalStrut(5)); //some room below label toalign with the labels at the left

85

}87 gbc.gridx = i+3;

gbc.gridwidth = 1; //set back to normal89 gbc.anchor = GridBagConstraints.PAGE_START; //keep this box always in

the top center of the cell//gbc.insets.right = 3;

91 gbc.insets.bottom = 8;reviewColumns.add(box,gbc);

93 }nrOfReviewColumns = dTreeN; //subtract one for the labelPanel

95 }}

97 private void initPanel() {reviewColumns.removeAll();

99 nrOfReviewColumns = 0;initLabelCol();

101 initReviewColumns();}

103


super.paintComponent(g);107 dTree = DecisionTree.getInstance();

if (dTree != null) {109 if ((dTree.getNrOfReviews() != nrOfReviewColumns) || needsUpdate) {

initPanel();111 needsUpdate = false;

}113 }

else {115 initPanel();

}117 repainter.validate();

}119

class textListener implements PropertyChangeListener {121

public void propertyChange(PropertyChangeEvent e) {123 Object source = e.getSource();

dTree = DecisionTree.getInstance();125 Review rev = dTree.getReview((JComponent)source);

if (source instanceof JTextField) {127 JFormattedTextField valueField = (JFormattedTextField)source;

if (source == rev.getC2cTxtField()) {129 rev.setCost2Continue(Double.parseDouble((String)valueField.

getValue()));}

131 if (source == rev.getC2iTxtField()) {rev.setCost2Improve(Double.parseDouble((String)valueField.

getValue()));133 }

if (source == rev.getIpTxtField()) {135 rev.setImprovementPercentage(Double.parseDouble((String)

valueField.getValue()));}

137 for (int i=0; i<rev.getNrOfNextStates(); i++) {if (source == rev.getChanceTxtFields().get(i)) {

139 rev.setChance(i, Double.parseDouble((String)valueField.getValue()));

}

102


141 }}

143 }}

145

class spinnerListener implements ChangeListener {147

public void stateChanged(ChangeEvent e) {149

dTree = DecisionTree.getInstance(); //get a reference to thetree

151 JSpinner js = (JSpinner)(e.getSource()); //get a reference to thespinner throwing the event

int newNrOfNextStates = (Integer)js.getValue(); //Get the value from thespinner

153 Review rev = dTree.getReview(js); //get review that holdsthis spinner

rev.setNrOfNextStates(newNrOfNextStates); //set the nrofnext statesof the review to value in spinner

155 needsUpdate = true;repainter.validate();


159

}161

}

E.12 Review.java

package npd_supplychain_strategist;2 import java.util.ArrayList;import javax.swing.*;

4 import java.text.*;/**

6 ** @author Mathijs van Suilichem

8 */public class Review {

10 private int time;private double cost2Continue;

12 private double cost2Improve;private double improvePerc;

14 private int nrOfNextStates;private double[] chances;

16 private JFormattedTextField txtCost2Continue;private JFormattedTextField txtCost2Improve;

18 private JFormattedTextField txtImprovePerc;private JSpinner spinnerNrOfNextStates;

20 private ArrayList<JTextField> txtChances;

22

//Formats to format and parse numbers24 private NumberFormat percentageFormat;

private NumberFormat costFormat;26

//<editor-fold defaultstate="collapsed" desc="Constructor">28 public Review(int Time) {

txtCost2Continue = new JFormattedTextField(costFormat);30 txtCost2Continue.setColumns(5);

txtCost2Continue.setMaximumSize(txtCost2Continue.getPreferredSize());32 txtCost2Improve = new JFormattedTextField(costFormat);

txtCost2Improve.setColumns(5);

103


34 txtCost2Improve.setMaximumSize(txtCost2Improve.getPreferredSize());txtImprovePerc = new JFormattedTextField(percentageFormat);

36 txtImprovePerc.setColumns(5);txtImprovePerc.setMaximumSize(txtImprovePerc.getPreferredSize());

38 spinnerNrOfNextStates = new JSpinner(new SpinnerNumberModel(2,2,10,1));JSpinner.NumberEditor leftAlignedEditor = new JSpinner.NumberEditor(

spinnerNrOfNextStates); //needed to align to the left40 leftAlignedEditor.getTextField().setHorizontalAlignment(SwingUtilities.

CENTER);spinnerNrOfNextStates.setEditor(leftAlignedEditor);

42 spinnerNrOfNextStates.setMaximumSize(txtImprovePerc.getPreferredSize());//set this to same as a random JTextField before

txtChances = new ArrayList<JTextField>();44 chances = new double[] {0.5,0.5}; //also initialize the

chances array for 2 membersfor (int i=0; i<2; i++) { //there is a minimal amount of next

possible states of 2, so start defining two chance fields46 txtChances.add(new JFormattedTextField(percentageFormat));

txtChances.get(i).setText("0.5");48 txtChances.get(i).setColumns(5);

txtChances.get(i).setMaximumSize(txtChances.get(i).getPreferredSize());50 }

nrOfNextStates = 2; //Then of course also set thisto 2

52 this.time = Time;}

54 public Review(int Time,double Cost2Continue, double Cost2Improve, intNrOfNextStates, double ImprovePercentage, double[] Chances) {txtCost2Continue = new JFormattedTextField(costFormat);

56 txtCost2Continue.setColumns(5);txtCost2Improve = new JFormattedTextField(costFormat);

58 txtCost2Improve.setColumns(5);txtImprovePerc = new JFormattedTextField(percentageFormat);

60 txtImprovePerc.setColumns(5);spinnerNrOfNextStates = new JSpinner(new SpinnerNumberModel(NrOfNextStates

,2,10,1));62 JSpinner.DefaultEditor leftAlignedEditor = new JSpinner.DefaultEditor(

spinnerNrOfNextStates); //needed to align to the leftleftAlignedEditor.getTextField().setHorizontalAlignment(SwingUtilities.

CENTER);64 spinnerNrOfNextStates.setEditor(leftAlignedEditor);

txtChances = new ArrayList<JTextField>();66 for (int i=0; i<NrOfNextStates; i++) {

txtChances.add(new JFormattedTextField(percentageFormat));68 txtChances.get(i).setText(Double.toString(Chances[i]));

txtChances.get(i).setColumns(5);70 txtChances.get(i).setMaximumSize(txtChances.get(i).getPreferredSize());

}72 this.time = Time;

this.cost2Continue = Cost2Continue;74 this.cost2Improve = Cost2Improve;

this.improvePerc = ImprovePercentage;76 this.nrOfNextStates = NrOfNextStates;

this.chances = Chances;78 }

//</editor-fold>80

//<editor-fold defaultstate="collapsed" desc="Getters and Setters">82 public void setCost2Continue(double Cost) {

this.cost2Continue = Cost;84 this.txtCost2Continue.setText(Double.toString(Cost));

}86

104


public void setCost2Improve(double Cost) {88 this.cost2Improve = Cost;

this.txtCost2Improve.setText(Double.toString(Cost));90 }

92 public void setImprovementPercentage(double Improvement) {this.improvePerc = Improvement;

94 this.txtImprovePerc.setText(Double.toString(Improvement));}

96

public void setNrOfNextStates(int Nr) {98 this.nrOfNextStates = Nr;

spinnerNrOfNextStates.getModel().setValue(Nr);100 //Now copy the old array of chances, reinitialize it and fill again

double[] oldChances = new double[chances.length];102 System.arraycopy(chances, 0, oldChances, 0, chances.length);

this.chances = new double[Nr];104 int l = (Nr>=oldChances.length) ? oldChances.length : Nr;

System.arraycopy(oldChances,0, this.chances,0, l);106 //Now update the amount of textfields

this.txtChances.clear();108 for (int i=0; i<Nr;i++) {

this.txtChances.add(new JFormattedTextField(percentageFormat));110 this.txtChances.get(i).setText(Double.toString(this.chances[i]));

this.txtChances.get(i).setColumns(5);112 this.txtChances.get(i).setMaximumSize(this.txtChances.get(i).

getPreferredSize());}

114 }

116 public void setChances(double[] Chances) {this.chances = new double[Chances.length];

118 System.arraycopy(Chances,0,this.chances,0,Chances.length);for (int i=0; i<chances.length; i++) {

120 this.txtChances.get(i+1).setText(Double.toString(this.chances[i]));}

122 }

124 public void setChance(int position, double ChanceValue) {chances[position] = ChanceValue;

126 }

128 public int getTime() {return this.time;

130 }

132 public JTextField getC2cTxtField() {return this.txtCost2Continue;

134 }

136 public JTextField getC2iTxtField() {return this.txtCost2Improve;

138 }

140 public JTextField getIpTxtField() {return this.txtImprovePerc;

142 }

144 public JSpinner getNrofNextStatesSpinner() {return this.spinnerNrOfNextStates;

146 }

148 public ArrayList<JTextField> getChanceTxtFields() {

105


return this.txtChances;150 }

152 public double getCost2Continue() {return this.cost2Continue;

154 }

156 public double getCost2Improve() {return this.cost2Improve;

158 }

160 public double getImprovementPercentage() {return this.improvePerc;

162 }

164 public int getNrOfNextStates() {return this.nrOfNextStates;

166 }

168 public double[] getChances() {return this.chances;


172

public ArrayList<JComponent> getFields() {174 ArrayList<JComponent> returnList = new ArrayList<JComponent>();

//declare all textfields and put values in it176 JLabel timeLabel = new JLabel(" " + this.time); //some spaces to align a

little bitJTextField c2c = this.txtCost2Continue;

178 JTextField c2i = this.txtCost2Improve;JTextField ip = this.txtImprovePerc;

180 JSpinner nrn = this.spinnerNrOfNextStates;

182 c2c.setText(Double.toString(this.cost2Continue));c2i.setText(Double.toString(this.cost2Improve));

184 ip.setText(Double.toString(this.improvePerc));nrn.setValue(this.nrOfNextStates);

186

returnList.add(timeLabel);188 returnList.add(c2c);

returnList.add(c2i);190 returnList.add(ip);

returnList.add(nrn);192 for (JTextField f : txtChances) {

returnList.add(f);194 }

return returnList;196 }

198 }

E.13 Tree.java


/**4 *

* @author Mathijs van Suilichem6 */public class Tree {

8 private static int vector_X_inc_Amount = 50;private static int vector_Y_inc_Amount = 25;

106


10 public static int VECTOR_X = 200;public static int VECTOR_Y = 100;

12 public static final int NODE_RADIUS = 10;public static final int WORST_EXPECTED = 0;

14 public static final int MOST_LIKELY = 1;public static final int BEST_EXPECTED = 2;

16 public static final int BEST_POSSIBLE = 3;public static final int OFFSET_Y = 80;

18 public static final int OFFSET_X = 80;public static final byte CONTINUE = 0;

20 public static final byte IMPROVE = 1;public static final byte ABANDON = 2;

22

public static String roundPerformance(double Number,int roundAmount) {24 String returnValue = String.format("%." + Integer.toString(roundAmount) + "

f%n", Number);return returnValue;

26 }public static String roundFinance(double Number,int roundAmount) {

28 String returnValue = String.format("\u20AC %." + Integer.toString(roundAmount) + "f%n", Number);

return returnValue;30 }

32 public static void stretchY() {VECTOR_Y += vector_Y_inc_Amount;

34 }public static void crimpY() {

36 VECTOR_Y -= VECTOR_Y > vector_Y_inc_Amount?vector_Y_inc_Amount:0; //onlyshrink when it is not minimum

}38 public static void stretchX() {

VECTOR_X += vector_X_inc_Amount;40 }

public static void crimpX() {42 VECTOR_X -= VECTOR_X > vector_X_inc_Amount?vector_X_inc_Amount:0;

}44 }

E.14 ValueCalculator.java


/**4 *

* @author Mathijs van Suilichem6 * This interface is used to calculate the financial value of a performance and can

be implemented fort yield performance, CYcle time performance, CoG performanceetc.

*/8 public interface ValueCalculator {

10 public double calculateValue(double Performance);}

E.15 YieldCalculator.java

1 /** To change this template, choose Tools | Templates

3 * and open the template in the editor.

*/5

107



/**9 *

* @author Mathijs van Suilichem11 */

public class YieldCalculator implements ValueCalculator{13 private int yearProd;

private int yearPayback;15 private double CoG;

private double target;17

public YieldCalculator(double CoG, int ProductionPerYear, int YearsForPayback,double TargetPerformance) {

19 this.CoG = CoG;this.yearPayback = YearsForPayback;

21 this.yearProd = ProductionPerYear;this.target = TargetPerformance;

23 }public double calculateValue(double performance) {

25 return (CoG*yearPayback*yearProd*(performance-target));}

27

}

108

Master Thesis: Making the right New Product...

Documents

Transcript of Master Thesis: Making the right New Product...