scheduling in a realistic environment using ... - Semantic Scholar

SCHEDULING IN A REALISTIC ENVIRONMENT USING AUTONOMOUS AGENTS: A SIMULATION STUDY Raffaele Pesenti DIAI Università degli Studi di Palermo 90128, Viale delle Scienze, Palermo, Italy E-mail: [email protected]

KEYWORDS Autonomous Agents, Simulation.

Dispatching

Rules,

Scheduling,

ABSTRACT In this paper, autonomous agent techniques are tested in a detailed simulation model of an existing factory. Set-up times, transportation times, failures of machines and other aspects sometimes disregarded in the literature are considered. The results obtained using autonomous agents as possible shop control systems are compared with the ones attained by dispatching rules. INTRODUCTION A detailed simulation model of an existing firm producing printed plastic items has been developed. The complexity of the real system was reproduced in the simulation model taking into account even details sometimes disregarded in the literature: set-up times, transportation times, failures of machines, etc. Such a model was then used as a test bed to compare dispatching rules versus autonomous agents as possible shop control systems. Tardiness is penalized in the real firm. As a consequence, tardiness-based measures have been chosen for evaluating the relative performance of the control techniques. Related work A recent and deep survey on general applications of autonomous agents in the field of manufacturing can be found in (Shen and Norrie 1999). However very few quantitative studies are known (Adacher et al. 2000). The basic idea of negotiation between agents can be found in (Smith 1980), a paper which introduces the contract net protocol which can be considered as the common denominator in autonomous agent studies. In (Malone and Smith 1988) several basic models are developed for comparing the performance of coordination structures that appear in a wide variety of systems, so giving a theoretical confirmation of the opportunity to use decentralized control in some particular situations. In (Baker 1988) one of the first applications of contract net to manufacturing is proposed. Other interesting studies are in (Lin and Solberg 1992), which presents a framework based on a market-like model

Lorenzo Castelli Pierluigi Santin DEEI Università degli Studi di Trieste 34127, Via A. Valerio 10, Trieste, Italy E-mail: [email protected]

and a combination of objective and price mechanism; in (Shen and Norrie 1998), where a negotiation mechanism, using the help of a mediator agent, is presented; in (Sousa and Ramos 1999), where the authors present a suitable negotiation protocol for the dynamic scheduling of tasks. Different studies on autonomous agents, viewed as holons, performed by the KULeuven group, are well summarized in (Wyns 1999). Interesting and recent simulation works for testing the proposed autonomous agent architectures for manufacturing scheduling can be found in (Saad et al. 1997; Kouiss et al. 1997; Krothapalli and Deshmukh 1999; Adacher et al. 2000; Brennan and O 2000). These papers present frameworks where either machine failures, or transportation times, or other aspects are disregarded. However, the above simplifications cannot be always acceptable. For this reason, in our work autonomous agents are tested in a more detailed environment. Dispatching rules are widely used in the manufacturing practice, due to their simplicity, efficiency and their nature of on-line algorithm (Holthaus 1997; Blackstone et al. 1982). Even if dispatching rules can easily be implemented in a distributed environment (Baker 1998) because of their implicit local nature, a traditional shop floor driven by dispatching rules cannot be considered as an autonomous agent structure. On one hand, since the workload of a machine is typically assigned by an external dispatcher and usually machines cannot react to it; on the other hand, since no real cooperation or negotiation takes place among the agents. The rest of the paper is organized as follows. In the next section the system considered is described. Then, the dispatching rules used for comparison and the autounomous agent control system are introduced. Finally, the results obtained are presented and some conclusions are drawn. THE SIMULATED SYSTEM There are 21 machines in the plant. Some machines can be clustered together when they perform the same action. More than 1000 different items are produced: each of them has to be worked on 2 or more machines. Typically if an item needs a particular action, it can choose between two or more

machines of the cluster devoted to the needed action. There are not re-workings on the same article. Some machines need a set-up time before switching from the production of an item to the production of another different item. Machine failures are possible as in the real system. The flow of work in progress is assured by a system of AGVs. Work orders can arrive at unforeseen times from 8:00 AM to 5:00 PM. The size of orders is typically small: this causes frequent changes of the produced item on machines causing problems in managing set-up times. Each order is divided on pallets each of one carries 400 plastic sheets. Preemption of an order is allowed between the processing of two different pallets, not between the sheets of the same pallet, because work in progress can move through the system only on a pallet. Not all the machines are continuously available: some work 24 hours per day, some others either 16 hours per day, or 8 hours per day; during the weekend the factory is closed. “Just in time” approach is applied in the real factory production. Due dates are fixed using TWK-method presented in (Blackstone et al. 1982). This simulation model has been implemented using the software eM-Plant (version 4.0) provided by Tecnomatix Technologies Ltd.

time t, where

sit = d i − t − ∑kqi= j piq ;

wit, j +1 : estimated

waiting time of the next operation at time t; ηmt : load level of machine m at time t; Z it : priority value of order i at time t. For all rules the highest priority is given to the order i* with Z it = min(Z it | i ∈ N mt ) . These parameters have to be calculated considering the environment in which dispatching rules are used. As an example, for the estimation of sit , the working periods of the machine must be considered: if a machine works from 6:00 AM to 10:00 PM, t=9:00 PM and di =7:00 AM of the next working day, slack is not equal to 10 hours, but to only 2 hours and so on. The following dispatching rules are used in this work; RR rule:   t st e −η m p + eη mt p + wt , Z it =  k i ij ij i , j +1 ∑ i p   q = j iq  where for simplicity wit, j +1 ≅ Wmt i , j +1 , and PT+WINQ+SL rule:  pij + min( sit ,0) if j = ki Z it =  t t  pij + Wmi , j +1 + min( si ,0) if j < ki .

Due to the nonterminating nature of the process to be simulated, a critical point is the determination of the warmup period, during which the output of the system cannot be considered in order to avoid biasing of the final result. A simple, but effective method found in (Banks et al. 1996) is used for cutting off warm-up period from each simulation run.

If more than one machine is able to perform the needed operation, a central dispatcher assigns one machine for each operation in order to balance the workload.

DISPATCHING RULES

AUTONOMOUS AGENT SYSTEM

Two dispatching rules particularly suited for minimizing tardiness-based measures can be found in (Holthaus 1997): RR and PT+WINQ+SL rules. The idea behind the two dispatching rules is to process preferably orders that can be completed sooner and for which not tardy completion time can more easily be achieved. In order to avoid excessive delays especially for long orders, the value of the slack is also used for the computation of the priority value: the smaller the slack, the bigger the possibility for the order of being chosen.

Complexity range of the negotiation protocols that can be applied is large. In this work simple negotiation rules are preferred to more complex ones in order to guarantee easy implementation and configuration.

For the description of these rules the following notation is used: m: index of the machine for which the job to be processed next has to be selected; t: time at which the priority values are calculated; i: index of the order for which the priority value is calculated; ri and di : release time and due-date of order i; ki : number of operations of order i; piq : processing time of q-th operation of order i; j: index of the operation for which order i is waiting at machine m; miq : machine on which the q-th operation of order i has to be processed; N mt : set of orders waiting for processing in the queue of machine m at time t; Wmt : work in the queue of machine m at time t, Wmt =

∑ t phjh ; sit : slack of order i at

h∈N m

The machines comprising the manufacturing process, the pallets and the orders are modeled as autonomous agents which interact dynamically to generate the production schedule. The interaction scheme makes use of a bidding mechanism based on the contract net protocol idea. In addition two other types of agent are introduced: transportation agents and a database agent. AGVs are modeled as transportation agents. A database agent, as a simple staff holon (Wyns 1999), has the function of collecting only data which are immutable, e.g., the possible not permutable sequences of machines which have to be visited by each article. Agents have to know time dependent information only through mutual interaction. Our negotiation protocol has been developed through several steps (from step1 to step6), whose details can be found in (Santin 2001). Each step adds a new feature to one or more agents of the system in order to increase the quality of agent interaction. A basic distinction can be made between part-centered bidding and machine-centered bidding (Saad et al. 1997). In

part-centered negotiation machines make bids and compete with each other to obtain a part for processing: the part awards itself to the machine offering the best bid. In machine-centered negotiation parts make bids to the machines: the machine accepts to process the part more attractive. As explained in what follows, our approach can be considered a mixture of these previous ones: in its sixth step, our negotiation protocol let pallet agent make the final choice, but only among machines which has previously given it their permission.

crtl_lists of the other machines, then can request transportation to the transportation agent which is responsible for the buffer where it is. Transportation agents apply FIFO discipline in managing multiple transportation requests. Note that a communication path between machines must also be implemented: in the computation of Z it

Our work presents an integration of PT+WINQ+SL rule (the most simple of the previous two) in the negotiation protocol. Interesting mixed models using dispatching rules and autonomous agents have already been developed (Baker 1998; Brennan and O 2000; Saad et al. 1997; Kouiss et al. 1997). However in our work the use of the dispatching rule is different from what found in literature and, in addition, our protocol considers set-up times, a dimension of the problem sometimes neglected for simplicity.

Step6

Step1

In step6 pallet agents have a more active role in the negotiation protocol. As in step1, each machine agent has its ctrl_list, in which pallet notifications of presence are recorded, but, in addition, it has another list, called order_list. This list has the function of a reservation register for the machine agent: here pallets which will be processed on that machine are recorded. Once the input buffer has become empty, if order_list is not empty, machine “calls for processing” one of the pallets recorded there in FIFO order. If order_list is empty, machine agent, by means of the dispatching rule, “elects” one of the pallets recorded in its ctrl_list, giving it the chance to begin a bargaining phase with all machine agents able to perform the needed action. Elected pallet communicates with these machine agents, whose buffer or order_list may even be not empty, in order to have both an evaluation of waiting time and a permission of being processed. Then pallet agent chooses the machine with lowest waiting time evaluation among the ones which have given positive permission of processing and reserves its next operation by means of a record in the order_list of the chosen machine.

The first step of our work has been the implementation of PT+WINQ+SL in a distributed architecture (we refer to this part as step1). A machine-centered bidding scheme and a distributed multi-agent search can easily be recognized in the following description. The agents cooperate by means of simple rules and by the exchange of simple messages to solve a problem in absence of a central coordination mechanism: work load is not decided by a central dispatcher as using simple dispatching schemes, but on-line from the concurrent cooperation between agents. Each pallet, once an operation has been completed, requests from the database agent the list of the machines able to perform the next needed operation. Then it makes a “notification of presence” to all these machines. Machine agents take care of this notification of presence by means of a record in a table called ctrl_list. When the input buffer of the machine becomes empty, the machine agent, if machine is not failed, has to select one of the pallets in its ctrl_list. Each pallet belongs to an order whose agent behaves as a supervisor for its pallet agents, so the machine agent sends a “request for information” to each order agent which has at least one pallet recorded in its ctrl_list. Order data, which are constituted by the information necessary for priority value computation, are collected and recorded in proper fields of the ctrl_list. The selection is made using the dispatching rule as a way to evaluate the convenience of processing a particular order. Set-up times have to be avoided when possible. Machine agent bases its choice on the following mechanism: 1) it considers the article for which is currently set (called last_art_proc); 2) it checks the presence in its ctrl_list of pallets carrying last_art_proc; 3) if presence of last_art_proc is detected, the machine agent selects one of the orders, which have pallets with last_art_proc, recorded in ctrl_list using the dispatching rule, otherwise the selection is made among all orders; 4) selection is communicated to one of the pallets of the selected order; 5) first of all, this pallet has to retire its notification of presence from the

machine agent needs the value of Wmt i , j +1 , which cannot be calculated without an exchange of information between machine agents.

The aspect of negotiation between pallet agent and machine agent, which in step1 is extremely simplified, has been improved. Each of the new dimensions added to the interaction between pallet and machine agents has gained better tardiness based measures of performance. In what follows, step6, the final product of the “evolution” started from step1, is presented.

empty order_list

pallet election buffer_aaa

request

req ue st

Machine1

order_list id_number

Machine2

empty buffer

position

article

order_list id_number

position

article

120001

buffer_aaa

Figure 1: Pallet Election As an example of pallet election, consider Figure 1 (boxes represent pallets and different colors represent different articles) and Figure 2 where an UML Sequence Diagram (Booch et al. 1999) explains the behavior of the generic pallet agent. Machine1 has empty buffer and empty order_list, so it elects one of the pallets recorded in its ctrl_list (not reproduced in Figure 1). Elected pallet begins a

P a lle t 1

p a lle t 1 e n t e r s in a b u ffe r

P a lle t 2

D a ta b a s e

O rd e r1

O rd e r2

M a c h in e 1

M a c h in e 2

n e x t_ m a c h in e s ? ( )

n o tify _ p re s e n c e () p a lle t 1 m a k e s it s " n o t if ic a t io n s o f p re s e n c e "

n o tify _ p re s e n c e ( )

p a lle t 2 e n t e r s in a b u ffe r

n e x t _ m a c h in e s ? ( )

M a c h in e checks p e r io d ic a lly th e s ta tu s o f its b u ffe r

n o t if y _ p r e s e n c e ( )

c h e c k _ b u ffe r()

c h e c k _ b u ffe r()

{ if b u f f e r e m p ty }

c h e c k _ o r d e r _ lis t ( ) re q u e s t_ o rd e r_ d a ta ()

{ if o r d e r _ lis t e m p ty }

re q u e s t_ o rd e r_ d a ta ()

p a lle t _ e le c t io n ( )

b e g in _ b a r g a in in g _ p h a s e ( )

w a it in g _ t im e _ e v a lu a t io n ( ) e le c t e d p a lle t re q u e s ts w a it in g t im e e v a lu a t io n a n d p ro c e s s in g p e rm is s io n

w a it in g _ t im e _ e v a lu a t io n ( )

r e q u e s t _ p r o c e s s in g _ p e r m is s io n ( )

r e q u e s t _ p r o c e s s in g _ p e r m is s io n ( )

p a lle t c h o o s e s a m a c h in e

m a c h in e _ c h o ic e ( )

u p d a t e _ o r d e r _ lis t ( )

c a n c e l_ n o tific a tio n ( )

Figure 2: UML Sequence Diagram for Step6 communication process with all the machines able to perform the needed action (suppose Machine2 and, obviously, Machine1). Suppose that each of them gives its permission of processing to the elected pallet: this one has to choose one machine on the basis of the expected waiting time received from the machines. Waiting time evaluation for machine1 is equal to residual processing time of the pallet currently on the machine plus the set-up time necessary for switching to the production of the article carried by the elected pallet. Waiting time evaluation for machine2 is equal to residual processing time of the pallet on the machine plus processing time of the pallet in the input buffer and of the pallet recorded in the order_list (no set-up times are added because the elected pallet carries the same article of the pallets which machine2 has to process). Transportation times are not considered since machines that can be chosen for the processing of a given article are usually located one near the other. Suppose that the evaluation for machine2 is the lowest:

elected pallet agent reserves its next operation on machine2 (this information is recorded by a new record in the order_list) and waits for a call for processing from machine2. If a machine failure occurs, machine agent releases the pallets eventually in its order_list (they have to begin a new phase communicating their notifications of presence to the machines an so on) and gives no more permissions of processing until failure persists. Pallet agents which can be processed by other machines, automatically avoid the failed machine without the necessity of special algorithms or behaviors to manage the problematic situation. Different pallet agents of the same order agent behave independently. There is the possibility of undesired situations in which some pallets have yet completed their processing sequence and are waiting for a long time the completion of the other pallets. Extremely long pauses (more than 24 hours

the order which does not require set-up is computed; 2) calling s t the slack computed, as done before, not considering set-up times, and psetup the set-up time of the machine, machine agent computes the slack of the order t t = s t − psetup ; 3) if ssetup >0 which requires setup as ssetup

PERFORMANCE EVALUATION ANOVA and Duncan’s multiple range test (Montgomery 1997) has been used with significance level α = 1% in order to verify that performance measures are significantly different. Experimental data are summarized by means of a box plot (Montgomery 1997): in Figure 3 and in Figure 4 the gray bar indicates the mean, the box extends from the 25th percentile to the 75th percentile and a vertical line extends from the minimum to the maximum values. M E A N T A R D IN E S S 21500 19500 17500 15500 seconds

In step1, machine agent processes all the waiting pallets carrying the article for which is currently set before switching to the production of a new article. Machine agent automatically creates “batches” of similar pallets in order to avoid excessive set-ups. This approach has been improved in order to avoid that orders with high priority may be delayed since they do not carry the same article of the batch currently processed. Machine agent decides carefully to set-up if it can avoid it. If there are no pallets of orders which do not require set-up but there are pallets with flag set as true, the choice is restricted to these ones in order to speed up their production. So pallets to speed up are considered only in situations where set-up times are unavoidable in order not to modify system behavior when it can be very effective (when set-up times are avoidable). When both the input buffer and the order_list are empty and machine agent has to elect a pallet, it computes priority values for all the orders with a pallet recorded in its ctrl_list. These orders can be divided in 2 categories: orders which require set-up and orders which do not. For each of them machine agent selects the order with the lowest priority value. Machine agent has to make its final choice among t these two. The mechanism used is: 1) the slack sno _ setup of

is negative. Note that an order cannot be refused by all the machines: at least the answer of the machine which elected the pallet will be positive.

13500 11500 9500 7500 5500 3500 1500 RR

P T + W IN Q + S L

5000 4500 4000 3500 3000 2500 2000 1500 1000 s te p 5

t sno _ setup > 0 , then machine agent elects one of the pallets of

the order which requires set-up. The last aspect of step6 which has to be explained is the following: machine agent, when receives a request for processing by an elected pallet, has to decide to give positive answer or not. By means of the following simple rule, machine agent avoids the possibility that an elected pallet could interrupt the processing of a batch of pallets causing set-ups which could be avoidable. Machine agent checks the article for which will be set if the requesting pallet agent will be processed by the machine (call this article last_art_proc) and then checks if there are pallets carrying last_art_proc in its ctrl_list. Machine gives positive answer if: 1) requesting pallet carries last_art_proc; 2) requesting pallet does not carry last_art_proc, but there are no pallets carrying last_art_proc recorded in its ctrl_list; otherwise the answer

s te p 6

P m ean

machine agent elects one of the pallets of the order which t t and sno does not require set-up; 3) if both ssetup _ setup are negative machine agent elects one of the pallets of the order t < 0 and which does not require set-up; 4) if s setup

s te p 1

Figure 3: Mean Tardiness

seconds

in our model) in the production of an order are not tolerated: this is not a theoretical, but a practical necessity for a more efficient management of the store where orders, ready to be sent to customers, are put. Order agent acts as a supervisor for its pallet agents: if it detects a pause longer than 24 hours, a boolean flag of the pallet agents not yet completed is set as true. Machine agents consider this flag in the process of pallet election: pallets with flag set as true are preferred as explained in what follows.

s te p 6

Figure 4: Pmean Figure 3 shows that step1 obtains a significant improvement respect to PT+WINQ+SL so as step6 respect to step1 in terms of mean tardiness. Step6 obtains significantly the best performances even in terms of maximum tardiness, variance of tardiness and percentage of tardy jobs. Performance improvement given by the control of long pauses in the production of an order cannot be evaluated using tardiness-based measures. An ad hoc measure has been developed. We indicate as Pijmax the longest pause of the production of the i-th order of the j-th simulation run and associate to this order the value 0 if Pijmax < 24 hours Pij =  max if Pijmax ≥ 24 hours .  Pij For each simulation run, we consider the value N

j Pmean = ∑ Pij . If pause control is disconnected in step6, what i =1

we call step5 is obtained. Figure 4 presents the significant improvement in terms of Pmean obtained using pause control mechanism. Differences between step5 and step6 about tardiness based measures have not appeared statistically significant. CONCLUSIONS Our test-bed and simulation experiments have generated interesting results in heterarchical production scheduling. The merits of the proposed bidding technique have been established and analysis of results have pointed out directions for extending our protocol. From an Artificial Intelligence point of view (Saad et al. 1997) this framework is interesting for three reasons: 1) it demonstrates the possibility to efficiently solve a computationally complex problem (scheduling problem) by means of a high distributed architecture of extremely simple entities; 2) it permits to study the role of local heuristics in determining schedules that are effective from a global point of view; 3) it shows the performance improvements that an higher degrees of collaboration (step6) can achieve respect to lower ones (step1). The presented protocol is not currently implemented in a real distributed environment (eM-Plant simulation code constitutes a single program running as a single tread on a single computer), but work will be done to implement this protocol, or more advanced versions of it, in a real, not simulated, distributed environment using Java programming language for the implementation of the agents. This Java agent system will be tested using eM-Plant in order to simulate a manufacturing system whose entities communicate for control through TCP/IP with Java agents. REFERENCES Adacher, L.; A. Agnetis and C. Meloni. 2000. “A Simulation Study of Autonomous Agents in FMSs”. IIE Transactions 32, No.10, 941-951. Baker, A.D. 1988. “Complete Manufacturing Control Using A Contract Net: A Simulation Study”. Proceedings of 1988 International Conference on Computer Integrated Manufacturing (New York, N.Y., May 23-25). IEEE, Piscataway, N.J., 100-109. Baker, A.D. 1998. “A Survey of Factory Control Algorithms which can be implemented in a Multi Agent Heterarchy: Dispatching, Scheduling and Pull”. Journal of Manufacturing Systems 37, No.4, 297-320. Banks, J; J.S. Carson II; and B.L. Nelson. 1996. Discrete-Event System Simulation. Prentice-Hall, Upper Saddle River, N.J. Blackstone, J.H.; D.T. Phillips, and G.L. Hogg. 1982, “ A State-ofthe-Art Survey of Dispatching Rules for Manufacturing Job Shop Operations”. International Journal of Production Research 20, No.1, 27-45. Booch G.; J. Rumbaugh; and I. Jacobson. 1999. The Unified Modeling Language User Guide. Addison Wesley, Reading, Massachusetts. Brennan, R.W. and W. O. 2000 “A Simulation Test-Bed to Evaluate Multi-Agent Control of Manufacturing Systems”. In Proceedings of the 2000 Winter Simulation Conference (Orlando, FL, Dec. 10-13). J.A. Joines, R.R. Barton, K. Kang, and P.A. Fishwick, eds, 1747-1756.

Holthaus, O. 1997. “Design of Efficient Job Shop Scheduling Rules”. Computers and Industrial Engineering 33, No. 1, 245252. Kouiss, K; H. Pierreval; and N. Mebarki. 1997. “Using multi-agent architecture in FMS for dynamic scheduling.” Journal of Intelligent Manufacturing 8, No.1, 41-47. Krothapalli, N.K.C. and A.V. Deshmukh. 1999. “Design of Negotiation Protocols for Multi-Agent Manufacturing Systems”. International Journal of Production Research 37, No.7, 1601-1624. Lin, G.Y. and J. Solberg. 1992. “Integrated Shop Floor Control Using Autonomous Agents”. IIE Transactions 24, No.3, 57-71. Malone, T.W. and S.A. Smith. 1988. “Modeling the Performance of Organizational Structures”. Operations Research 36, No.3, 421-436. Montgomery, D.C. 1997. Design and Analysis of Experiments. John Wiley & Sons, New York, N.J. Saad, A.; K. Kawamura; and G. Biswas. 1997. “Performance Evaluation of Contract Net-Based Heterarchical Scheduling for Flexible Manufacturing Systems.” Intelligent Automation and Soft Computing 3, No. 3, 229-248. Santin, P. 2001. “Un Sistema ad Agenti Autonomi per la Schedulazione della Produzione in Tempo Reale”. Tesi di Laurea. Università degli Studi di Trieste, 34127, Via A. Valerio 10, Trieste, Italy – in italian. Shen, W. and D.H. Norrie. 1998. “Combining Mediation and Bidding Mechanism for Agent Based Manufacturing Scheduling”. Proceedings of Second International Conference on Autonomous Agents (Agents’98), (Minneapolis, May 9-13, 1998). ACM Press, 469-470. Shen, W. and D.H. Norrie. 1999. “Agent Based Systems for Intelligent Manufacturing: A State-of-the-Art Survey”. Knowledge and Information Systems 1, No.2, 129-156. Smith, R.G. 1980. “The Contract Net Protocol: High Level Communication and Control in a Distributed Problem Solver”. IEEE Transactions on Computers 12, 1104-1113. Sousa, P. and C. Ramos. 1999. “A distributed architecture and negotiation protocol for scheduling in manufacturing systems”. Computers in Industry 38, No.2, 103-113. Wyns, J. 1999. “Reference Architecture for Holonic Manufacturing Systems” Phd Thesis, KULeuven, Katholieke Universiteit Leuven, Faculteit Toegepaste Wetenschappen, Departement Werktuigkunde Afdeling Productietechnieken, Machinebouw en Automatisering, Celestijnenlaan 300B-B-3001, Heverlee (Leuven), Belgium.

AUTHOR BIOGRAPHY RAFFAELE PESENTI is associate professor at the University of Palermo, Italy. His research is focused on logistics. His works appeared on IEEE Trans. on Automatic Control, IEEE Trans. on Robotics and Automation, Simulations, European Journal of Operation Research and other international journals. LORENZO CASTELLI is currently a Ph.D. student at the University of Trieste, Italy. His research activity is related to performance evaluation methodologies and simulation. His works appeared in the European Journal of Operational Research. PIERLUIGI SANTIN is going to be graduated in Electronic Engineering at the University of Trieste, Italy. This work is part of his thesis.