molde: a workﬂow language for the modelling of manufacture

UNIVERSIDAD DE LOS ANDESFACULTAD DE INGENIERIADepartamento de Sistemas

y ComputacionGrupo de construccion de software

MoLde: A workflow language for the modellingof manufacture systems

Jaime Andres Romero

Thesis presented to acquire the title ofMagıster in System and Computing Engineering of

Universidad de los Andes

August, 2014

Advisor: Prof. Dr. Rubby CasallasProf. David MendezProf. Juan Pablo Caballero

Resumen

En este documento se presenta un lenguaje de dominio especıfico para mode-lar sistemas de manufactura (MoLde) con el objetivo de facilitar el proceso demodelaje que incurre un ingeniero industrial. Un sistema de manufactura es unproceso (conjunto de tareas) que tiene como objetivo la creacion de un productoo terminar un conjunto de trabajos. Este conjunto de tareas tiene un flujo decontrol, recursos que se necesitan para llevarlo acabo(maquinaria, trabajadores,herramientas) y restricciones adicionales que involucran la relacion tarea-recurso,o la relacion trabajo-tarea. Actualmente un ingeniero industrial cuando quiereestudiar un sistema de este tipo escoge una de las diferentes estructuras de mod-elamiento y algoritmos definidos sobre esta estructura. El problema con esteenfoque es que la mayorıa de estas estructuras son de ”bajo nivel” (conceptosno cercanos al mundo del problema) es por esta razon que el modelador tieneque hacer una traduccion del mundo del problema al mundo de la estructura dedatos que implica que el proceso consuma tiempo, se necesite de conocimientode la estructura y que el modelador incurra a errores. Una de las estructurasmas usadas para el modelamiento de sistemas de manufactura son las redes dePetri debido a que mediante el uso de esta se puede modelar un gran conjunto delos eventos presentes en este tipo de sistemas. YAWL es un lenguaje de controlde flujo usado para describir procesos de negocio, su sintaxis esta basada en losconceptos de la red de petri. Este lenguaje nos permite expresar muchas de lasrestricciones de control de flujo presentes en un sistema de manufactura. Pero nonos permite expresar los recursos del sistema y las restricciones que involucranla relacion tarea-recurso y la relacion trabajo-tarea. MoLDe es una extesion aYAWL, nosotros incorporamos nuevos conceptos y cambiamos algunos conceptosexistentes en YAWL para poder expresar un sistema de manufactura completo.En este trabajo se presenta este lenguaje y como se puede usar mediante el usode algunos ejemplos.Tambien se describe un esquema de transformacion a redesde Petri que tiene como objetivo el uso de algoritmos definidos sobre esta estruc-tura. Mostramos las herramientas de software desarrolladas en el proyecto. Ypor ultimo se incluye el proceso de validacion del lenguaje.

i

Abstract

This document presents a domain specific language to model manufacture sys-tems (MoLde) aimed to make easier the modelling process of an industrial en-gineer. A manufacture system is a process (set of tasks) with the objective ofcreating a product or to finish a set of jobs. The set of tasks has restrictionsof control flow, resources that are needed to perform a certain task (machinery,worker, tools) and other restrictions among the relationship between resource-task and among the relationship between job-task. Now a days an industrialengineer when he want to study this type of systems he use different modellingstructures and algorithms defined over this structures. The problem with thisapproach is that this structures are ”low level” (concepts not close to the onespresent in the world of the manufacture systems) making the modelling processdifficult, time consuming, and susceptible to mistakes. One of the most usedmodelling structures is the Petri-net because it let express a big set of eventspresent in the world of the problem. YAWL is language with a syntax basedon Petri-net that lets us express the control flow of manufacture systems. Butconcepts like resources, restrictions among tasks and resources, and restrictionsamong jobs and tasks can not be expressed using this language. MoLde is anextension to YAWL, adding concepts that let the modeler express resources andadditional restrictions present in the world of the manufacture systems. In thiswork we present the language syntax and how to use the language to modelsome specific examples. Also we present a transformation schema of the con-cepts of MoLde to Petri-net, to be able to use the related work and some of thealgorithms implemented over this structure. We show the software tools imple-mented for this project. And for the last part we include the validation processof the language.

ii

Acknowlegements

This work was supported by the PyLO (Production and Logistics) and TICSw(Information Technologies and Software Construction) research groups of theSchool of Engineering of the Universidad de los Andes. Also was specially sup-ported by Prof. Dr. Rubby Casallas, Prof. Juan Pablo Caballero and Prof.David Mendez.

iii

Table of Contents

Resumen i

Abstract i

Acknowlegements ii

Table of contents v

1 Introduction 3

2 Basic Concepts 5

2.1 Flexible Manufacture Systems . . . . . . . . . . . . . . . . . . . . 5

2.1.1 Formal definition for the FMS:. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.1.2 Assumptions . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2 Petri-nets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2.1 Formal definition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.2.2 Modeling with Petri-net. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3 REPAG- Petri-net and Genetic Algorithms . . . . . . . . . . . . 7

3 Problem 9

3.1 Objectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4 Related Work 11

4.1 Modelling Representations and Algorithms . . . . . . . . . . . . 11

4.1.1 Activity cycle diagram . . . . . . . . . . . . . . . . . . . . 11

4.1.2 IDEF0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.1.3 Petri-net . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.1.4 Object-oriented modelling . . . . . . . . . . . . . . . . . . 12

4.1.5 Heuristics . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.2 TimeNET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.3 YAWL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

5 MoLde: Proposed Language 15

5.1 Strategy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

5.1.1 Abstract Syntax . . . . . . . . . . . . . . . . . . . . . . . 15

5.1.2 Concrete Syntax . . . . . . . . . . . . . . . . . . . . . . . 17

5.1.3 Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

5.2 Syntax Restrictions . . . . . . . . . . . . . . . . . . . . . . . . . . 18

v

vi Table of Contents

5.3 Transformations Rules . . . . . . . . . . . . . . . . . . . . . . . . 20

5.3.1 Independent Input Condition . . . . . . . . . . . . . . . . 20

5.3.2 Output Condition . . . . . . . . . . . . . . . . . . . . . . 21

5.3.3 Resource . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

5.3.4 Atomic Task - Setup Time = 0 and Percent Completion =100 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

5.3.5 Atomic Task - Setup Time = 0 and Percent Completion <100 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

5.3.6 Atomic Task - Non Anticipated Setup Time > 0 and Per-cent Completion = 100 . . . . . . . . . . . . . . . . . . . 22

5.3.7 Atomic Task - Non Anticipated Setup Time > 0 and Per-cent Completion < 100 . . . . . . . . . . . . . . . . . . . 22

5.3.8 Atomic Task - Anticipated Setup Time > 0 and PercentCompletion = 100 . . . . . . . . . . . . . . . . . . . . . . 23

5.3.9 Atomic Task - Anticipated Setup Time > 0 and PercentCompletion < 100 . . . . . . . . . . . . . . . . . . . . . . 23

5.3.10 Transition . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

5.3.11 Trigger . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

5.3.12 Multiple Instance task . . . . . . . . . . . . . . . . . . . . 25

5.3.13 And Join . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

5.3.14 And Split . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

5.3.15 Xor Join . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

5.3.16 Xor Split . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

5.3.17 Lag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

5.3.18 Composite Task . . . . . . . . . . . . . . . . . . . . . . . 27

6 Case Style 29

6.1 Sequential manufacture systems . . . . . . . . . . . . . . . . . . . 29

6.1.1 Process to manufacture a shovel . . . . . . . . . . . . . . 29

6.1.2 Simple sequence . . . . . . . . . . . . . . . . . . . . . . . 29

6.1.3 And Join/Split . . . . . . . . . . . . . . . . . . . . . . . . 30

6.1.4 Xor Join/Split . . . . . . . . . . . . . . . . . . . . . . . . 30

6.2 Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

6.3 Multiple instance tasks . . . . . . . . . . . . . . . . . . . . . . . . 32

6.4 Subprocesses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

6.4.1 Composite Task . . . . . . . . . . . . . . . . . . . . . . . 34

6.4.2 Triggers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

7 Implementation 37

7.1 Language and editor . . . . . . . . . . . . . . . . . . . . . . . . . 37

7.2 Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

7.3 Other generated files . . . . . . . . . . . . . . . . . . . . . . . . . 37

7.4 How to use the plugins? . . . . . . . . . . . . . . . . . . . . . . . 38

8 Validation 43

8.1 Transformation Rules Validation . . . . . . . . . . . . . . . . . . 43

8.2 Language Expressiveness Validation . . . . . . . . . . . . . . . . 43

8.2.1 Fabrication of injection moulds . . . . . . . . . . . . . . . 44

8.3 Ceramic Tile production . . . . . . . . . . . . . . . . . . . . . . . 45

8.3.1 Case of Study . . . . . . . . . . . . . . . . . . . . . . . . . 45

Table of Contents 1

8.3.2 Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488.3.3 Transformation and Analysis . . . . . . . . . . . . . . . . 51

9 Conclusions and Future Work 53

2 Table of Contents

1Introduction

Real world systems are complex, hard to study, hard to manipulate and when anenterprise decide to change the real system implies costs that not always makethe system more efficient and productive. This is the situation where modelling isappealing to the enterprise for studying the system and its behaviour throughoutchanges over the model. This is applied also to manufacture systems.

A manufacture system is a process or a sequence of tasks with the purposeto produce a variety of products. This products are made using a set of limitedresources and usually have a designated time to be delivered. Specifically, aflexible manufacture system (FMS) gives certain flexibility to a manufacturesystem in terms of resources (Can perform different tasks), in terms of product(Produce different types of products), in terms of routes (Different possible routesfor the same type of product) among others[19].

In the literature we found different approaches to represent and solve manu-facture systems in [6] the author discusses the different modelling methodologiessuch as queuing networks, activity cycle diagrams, Petri-nets, IDEF0, objectoriented modelling, and so on. Many ways of representing this problem meansthat the solutions can not be reused.

Among many authors Caballero proposes in [4] that is able to represent a bigrange of manufacture systems using Petri-nets. A Petri-net is a graphical andmathematical modelling tool that let us represent the activities, resources andrestrictions of a manufacture system[13]. The petri nets are also a promisingtool to describe concurrent, asynchronous, distributed, parallel, non determin-istic and/or stochastic systems[16]. Some of this characteristics present on theflexibility of FMS making this structure suitable for representing them.

Despite the great utility of the Petri-nets, this representation has two prob-lems. First, this data structure has a low level of abstraction this makes that theconcepts of a FMS are not near to the concepts of the Petri-nets. This makesthat modelling with this representation consumes a lot of time and susceptible tomistakes of the modeller. Second, when modelling a small FMS, the associatedPetri-net is complex, difficult to manipulate and hard to visualize.

This article has as main objective to find a representation with a higher levelof abstraction that let us model FMS in a more easy way, with concepts closer for

3

4

the two domains. As a second objective we want to build equivalences betweenthe proposed language and the Petri-nets to be able to use the solution methodsfound in the literature, specifically the one proposed by Caballero in [4].

The main contributions of this work are: first a domain specific languagewhere we extend the YAWL language described in [7] to model FMS (MoLde).MoLde let us express the main characteristics found in a manufacture systems,the control flow among tasks, the dependence of tasks with resources and restric-tions between jobs-tasks, and between tasks-resources. Second a transformationschema that let us pass from the concepts of MoLde to concepts of a Petri-net.Third, model checking of the generated Petri-net using tools that run analysisover this structure, in this project we used TINA tool box. Fourth, the use ofthe solution method proposed in [4] to give solution to the scheduling problem.The validation process for MoLde was first to check the expressive capability ofthe language by means of different examples. Also we ask for the help of someindustrial engineers (PyLO research groups) to use the proposed language withthe develop tools to be able to have external retrospective over the solution.This process help us improve the tools and the proposed language. Second wecheck the transformation rules to the Petri-net with the purpose of checking theformation of the resulting Petri-net. For this part of the process we receive helpof experts(PyLO research groups) in Petri-nets.

The rest of the document is structured as follows: Chapter 2 we introducethe reader to some basic concepts to help the audience understand the rest ofthe article. Chapter 3 we describe the problem we want to attack with thisproject and the objectives we pursue. Chapter 4 we present to the audiencesome related research in the context of languages for representing a FMS andhow our solution differ from them. Chapter 5 we present the solution strategy.Chapter 6 we introduce the proposed workflow language its abstract and concretesyntax, some restrictions over the syntax, and the transformations rules we useto transform it to Petri-net. Chapter 7 we give a series of examples to teachthe modeller how to use the language. Chapter 8 we describe the tool built toconcrete the solution described in the paper and how to use it. Chapter 9 wetalk about the validation process of the proposed language. Chapter 10 we talkabout some conclusions and future work to guide the project.

2Basic Concepts

2.1 Flexible Manufacture Systems

A manufacture system is a set or sequence of tasks to produce a certain productusing a finite set of resources. A flexible manufacture system gives the followingcharacteristics to a manufacture system:

• Machineflexibility refers to the various types of operations or tasks thata certain machine can perform without requiring effort in switching fromone operation to another.

• Processflexibility is the ability to change between the production of dif-ferent products with minimal delay

• ProductF lexibility is the ability to change the mix of products in currentproduction

• Routingflexibility is the ability to vary the path of a part may takethrough the manufacture system

• V olumeflexibility is the ability to vary the operation production volumes.

• Expansionflexibility is the ability to expand the capacity of the systemas needed, easily and modularly.

• Operationflexibility is the ability to interchange sequence of the manu-facturing operations for a given part.

• Productionflexibility is the universe of part types that the manufacturesystem is able to make.

While the increased flexibility of a FMS provides a greater number of choicesof resources and routes, and allows greater productivity. The challenge is to allo-cate the given set of resources to different processes or tasks required in makingeach product and the scheduling of the sequence of activities to accomplish thebest efficiency.

5

6 2.2. Petri-nets

2.1.1 Formal definition for the FMS:

Indexes

i works, j operations, k machines, e stations

Sets

M machines, E stations, J jobs,Me machines in the stations eOi,e operations of the work i that has to be processed in the station e

Parameters

ai,j,k: time that takes an operation j in job j in machine k to be readydj : delivery datepj,i,k: processing time of the operation j of the job i in the machine k

A FMS is composed by a set of machines M and a set of jobs J that are go-ing to be scheduled. Each machine belongs to a unique subset Me of machinesdepending on the functionality of the station. Each job i is composed by a setof operations Oi,e. Each of this operations has to be done in the station e. Theprocessing time pj,i,k of the operations can change depending one the machinewhere it is scheduled.

2.1.2 Assumptions

• Each job j has a delivery date

• A job can pass through a station several times

• The machines in an stations are not necessarily equal, this means that theycan have different processing times for an specific job

• Each machine is available since time zero.

• Machines do not have failures

• The processing of an operation can not be interrupted.

• There are no more jobs entering the system different from the ones known.

• The time for a machine to be ready is equal for the ones that belong tothe same station

2.2 Petri-nets

A Petri-net is a particular kind of directed graph, together with an initial statecalled the initial marking, M0. The underlying graph is a directed, weighted,bipartite graph. It has two kinds of nodes, called places and transitions. Arcsare either from a place to a transition or from a transition to a place.

Basic Concepts 7

A marking (state) assigns to each place a non negative integer. When amarking (non negative integer k) is assigned to a place p, it means that theplace is marked with k tokens.

The marking is denoted M, an m-vector, where m is the total number ofplaces in the graph. The element with the pth position denoted M(p), is thenumber of tokens in the place p.

2.2.1 Formal definition

A Petri net is a 5-tuple, PN = (P, T, F,W,M0)

• P = {p0, p1, p2, ......., pm} finite set of places

• T = {t0, t1, t2, ......., tm} finite set of transitions

• F ⊆ (P × T ) ∪ (T × P ) set of arcs

• W : F → {1, 2, 3, .....} weight function

• M0 : F → {1, 2, 3, .....} initial marking

• P ∩ T = ∅ and P ∪ T = ∅

2.2.2 Modeling with Petri-net

In modelling, a transitions represent events and places conditions. A transitionhas a certain number of input and out places representing pre-conditions andpost-conditions of the event. The presence of a token in a place can be interpretedas if the conditions is achieved. Another interpretation k tokens indicate k dataitems or resources available.

In order to simulate the dynamic behaviour of a system, a state or markingis changed according to the following rules:

• A transition t is said to be enabled if each input place p of t is market atleast w(p, t) tokens(weight).

• An enabled transition may or may not fire (depending on whether or notthe event actually takes place)

• A firing of an enabled transition t removes w(p, t) tokens from each inputplace p of t, and adds w(t, p) tokens to each output place p of t.

2.3 REPAG- Petri-net and Genetic Algorithms

REPAG is an genetic algorithm using the Petri-net structure to obtain thefactible schedules for the problem in an specific manufacture system.This al-gorithm can be summarized in the following steps:

1. Create a initial population generated randomly. Then calculate the valueof adaptation with the criteria of weighted tardiness of the jobs, J .

8 2.3. REPAG- Petri-net and Genetic Algorithms

2. If there are k identical individuals, the value of adaptation is penalize withk − l of them with a high value so that the dominant genes can not causeearly convergence.

3. Assign the probability to be choose to every individual in the population.

4. Select pair of individuals in the population by the probabilities of step 3.Apply the strategy of reproduction and calculate the adaptation value withthe criteria of weighted tardiness.

5. Choose the best individuals between father and sons, the ones with betteradaptation values.

6. Choose the genes of the individuals that are going to go through the processof mutation.

7. If the number of generations is reached the algorithm finish and return theactual population, in the other case go to step 2.

3Problem

Real world systems are complex, hard to study, hard to manipulate and whenan enterprise perform changes over the real system implies costs that not alwaysmake the system more efficient and productive. This is the situation wheremodelling is appealing to the enterprise for studying the system and its behaviourthroughout changes over the model. This is applied also to manufacture systems.

In the literature we found different forms for modelling a flexible manufac-ture system. In [6] the author discusses some of modelling methodologies used.Having different ways for the representation of the same problem makes that thesolution found can not be reused, this means that a solution in an specific repre-sentation can only be compared to another solution(different representation) bymeans of the value of the objective function. The concepts in each representationare different and sometimes are not equivalent. This makes relevant to find arepresentation where we can model a big range of manufacture systems.

Among other authors in [4] the author proposes that this representation isthe Petri-net. We discuss in the last section some of the great characteristicsthat this representation has and that make it suitable for the representation andsolution of this kind of systems. But this representation has two big problems,first its low level of abstraction this means there is a gap between the concepts of aflexible manufacture system and the concepts of a Petri-net, and the equivalencebetween them is not intuitive. This makes the process of modelling a manufacturesystem time consuming and susceptible to mistakes. The second problem is thecomplexity of the structure, for a small instance of a manufacture system theassociated Petri-net is complex, hard to manipulate and hard to visualize.

Although we don’t want to use the Petri-nets for the modelling of manufac-ture systems; we want to include the solution schema of [4] to solve the schedulingproblem. This means the problem is to create a high level language to help withthe modelling of a flexible manufacture system. With an associated chain oftransformation to Petri-net with the purpose of using the solution schema pro-posed in [4] using this representation and be able to study the system in a moreappealing way for the modeller and the enterprise.

If we give a modeller a more intuitive language to express the desire system,this means an improvement in the process of modelling making it faster and less

9

10 3.1. Objectives

susceptible to mistakes.

3.1 Objectives

• Improve the modelling process of a industrial engineer when he wants tostudy a manufacture system by means of a domain specific language.

• Search for work-flow languages that let us express some of the character-istics present in manufacture systems to help us define a domain specificlanguage.

• Define transformation rules over the proposed language to be able to gen-erate a Petri-net that contains the information expressed in the language.

• Include the solution schema of [4], based on a genetic algorithm over thePetri-net to give a good solution to the scheduling problem for the desiresystem.

• Validate the proposed language with real manufacture system examples.

• Validate the proposed transformation schema with experts in Petri-net andintegrate tools for checking the generating net.

4Related Work

4.1 Modelling Representations and Algorithms

Flexible manufacture systems is an interesting topic in industrial engineering.That’s why many authors have been modelling them with alternative represen-tations and some of them solving the scheduling problem with algorithms over theproposed representation. In [6] the author discusses about the current modellingmethodologies used in flexible manufacture systems, such as queuing networks,activity cycle diagrams, IDEF0, Petri-nets, object-oriented methodologies, andso on.

4.1.1 Activity cycle diagram

An activity cycle diagram represents the changes of system status in a graphicalmanner, whereby taking advantage of the understanding and analysing manu-facturing system. However, the activity cycle diagram does not represent therelationship between conditions and events in the discrete events dynamic sys-tem.

4.1.2 IDEF0

IDEF0 is a modelling methodology for designing and documenting a hierarchic,layered, modular system. The IDEF0 methodology has been widely used [9]. Thebuilding block of this modelling approach is the activity box. The activity boxdefines a specific activity in the organization that is being modelled. Four typesof arrows are associated with an activity box. They are input, output, controland mechanism, respectively. Inputs are items (e.g. material, information) thatare transformed by the activity. Outputs are the results of the activity actingon the inputs. A control is a condition that governs the performance of theactivity. A mechanism is the means by which an activity is realized. An activitybox can be further broken down into several sub-activities. Nevertheless, thedisadvantage of IDEF0 methodology is its static nature, that is, it can onlyrepresent the static behaviour of a system.

11

12 4.2. TimeNET

4.1.3 Petri-net

Petri-nets are a formal graphical model for the description and analysis of systemsthat exhibit asynchronous, concurrent properties. Petri-nets and their variations,such as coloured Petri-nets and timed Petri-nets, have been widely applied tomodel, control and analyse the system’s dynamic behaviours due to the char-acteristics of the graphical representation and mathematical analysis of controllogic. A large number of Petri-net approaches to modelling and control of dis-crete manufacturing systems have been described in the literature, including [21],[11], [22], [13], [4], [5], among many others.

4.1.4 Object-oriented modelling

Object-oriented (O-O) technology is a new paradigm for modelling manufactur-ing systems and it has become widely used in application software development[12] [18]. The O-O modelling technique provides a one-to-one correspondencebetween the entities in a real system and the objects in its model that representthem. It possesses high modularity, maintainability, and reusability.

4.1.5 Heuristics

Flexible manufacture system and its associated scheduling problem has beenextensively studied with different approaches, exact and heuristic approaches.This approaches changes in the representation the author use and the heuristicapproach to solve the scheduling problem. Some of them use permutation vectorwith tabu search (with variations in the heuristic) [1], [15], [3], [8], [25], otheruse simulated annealing [8], [25] and [24]. Other representation are graphs andthe authors use different methods of the graph theory with other heuristics toattack the scheduling problem [14], [2] and [10].

4.2 TimeNET

TimeNET is a software tool for the modeling and performability evaluation usingstochastic Petri-nets. Its two main characteristics are the evaluation of modelswith non exponentially distributed firing delays and the ability to model andevaluate complex colored stochastic Petri-nets [26].

Although TimeNet is an amazing tool to evaluate stochastic and coloredPetri-nets and incorporates an editor to make the process of modelling easier,as we discussed earlier the Petri-net representation has a low abstraction levelthat makes the modelling process time consuming and susceptible to errors.Other issue of this tool is that the solution approach(solution method that wewant to include) proposed in [4] don’t use stochastic Petri-nets for the problemrepresentation. And also this tool evaluates certain characteristics of the Petri-net that is another complex problem that we don’t want to solve with this work.

4.3 YAWL

YAWL is a open-source work-flow system with its own work-flow language def-inition that captures all sorts of flow dependencies between tasks. YAWL is

Related Work 13

based on Petri-nets but extended with additional features to facilitate the mod-elling of complex work-flows. This system is used a tool to model or representbusiness process. The author exposes different patterns in [7] to illustrate the”expressiveness” of the proposed work-flow language.

Although YAWL is a very develop language in the business process man-agement and also can be represented in a Petri-net, when we begin modellingmanufacture systems with this language we find different problems or limitationsin the concepts of the language that didn’t let us represent the desire systems.Between the issues found are: the association of resources to the tasks, the as-sociation processing times to the tasks, multiple instances tasks with differenttimes and resources, triggers to other nets, among others. This make us thinkthat YAWL language is a good start point but its concepts most be extended torepresent the object of our study (flexible manufacture systems).

Van der Aalts base his language on Petri-nets with timed transitions as wediscussed earlier we integrate the work of [4] to the proposed solution but hebased his solution on Petri-nets with timed places, what makes us restructurethe transformations to Petri-nets that Van der Aalts made for his language.

14 4.3. YAWL

5MoLde: Proposed Language

5.1 Strategy

Through out the bibliographic revision we found that the concepts present inthe work-flow languages let us describe the flow restrictions among tasks presentin a manufacture system. Among those work-flow languages we find BPMN andYAWL. Although BPMN is one of the most used workflows language to describebusiness process, and have a lot of tools the helps with the model and executionof the model, we decide to use YAWL(Yet another workflow language) in thisproject because is a well develop language, it´s syntax is based on Petri-nets, andsome the patterns described by Van der Aalts in [20] are present in manufacturesystems. The main issue with this language is that doesn’t represent all theconcepts and restrictions present in a flexible manufacture system.

This is the reason why our strategy consists in extending the YAWL work-flowlanguage with the concepts that are needed to express a complete manufacturesystem. Change the transformation rules in YAWL to Petri-net to incorporatethe new concepts. And be able to construct tools to model the desire system,validate the constructed diagram, transform it to a Petri-net, and check thegenerated Petri-net. In this section, we will talk about the proposed language,its abstract and concrete syntax.

5.1.1 Abstract Syntax

In Figure 1 we can see the abstract Syntax of the proposed language. Here weexplain each of the concepts in of the language:

• System: Represent the manufacture system. A manufacture system typi-cally has some resources and some sub-nets.

• Sub − net: Represent a set of tasks to produce a certain type of product.A sub-net has certain elements and transitions over this elements.

• Resource: Represent a person or machine that is needed to perform a setof tasks.

15

16 5.1. Strategy

• Element: Represent either a task or condition that is needed on a sub-net.

• Transition: Represent a connection between to elements.

• Condition: Represent a condition to be able to perform a task.

• InputCondition: Represent a initial condition for a sub-net to begin. Atrigger can call the condition to the begin the sub-process.

• Trigger: Represents a start for other sub-nets (input conditions) that canbe done in parallel after an specific task.

• OutputCondition: Represent a final condition for a sub-net to finish.

• Task: Represent an operation or set of operations that are needed in theprocess to create a type of product.

• Atomic Task: Represent a single operations in the process to create a typeof product. An atomic task needs a resource to be done. The task can havea processing time that is the duration of the operation. This operation canhave a setup time associated to the resource that is using and this setuptime can be done before or after the job arrives. And also it can have apercent of completion the language, this means that is not necessary tofinish all the task to let the process continue.

• Multiple Instance Task: Represent a single operations that can be per-formed in parallel. This means that the manufacture system has the capa-bility to perform this operation with a set of resources (Different Instances).

• Instance: Represent a specific instance of the multiple instance task. Eachinstance has a processing time, setup times, percent of completion and anassociated resource where it is performed.

• Composite Task: Represent a set of operations in the process to create atype of product. A composite tasks has a associated sub net that specifiesthe order and transitions of the set of operations.

• ANDJoin: It can be used with any task concept. Represent that the taskhave to wait all the task that are connected to it to finish to start.

• ANDSplit It can be used with any task concept except. Represent thatthe task activate a series of tasks.

• XORJoin It can be used with any task concept. Represent that the taskcan begin whenever one of the tasks connected to it finish.

• XORSplit It can be used with any task concept. Represent that the taskcan activate some of the following tasks.

• Lag Represent a processing time that has to be done between two elementsof the system.

MoLde: Proposed Language 17

Figure 5.1 Language Metamodel

5.1.2 Concrete Syntax

In Figure 2 we can see the concrete syntax of the abstract syntax explained inlast section. Its based on the elements present in YAWL editor developed byVan der Aalts[7].

We can clarify that a system is represented by a box with two sections. Thefirst section is for the resources of the system. And the second section is for thesub nets of the system. A sub-net is another box with only one section, thissection is for the different tasks, conditions and transitions between them. Inthe figure is not clear that the transitions between elements are arrows betweenthem.

The tasks have different properties between them is the processing time andthe resource that is going to perform the task. This characteristics are notrepresented visually, are present in the section of properties of the editor of thespecific element. In the section of tools we talk more about the editor.

The only particular task that is different from the other elements is themultiple instance task where the instances are represented with small boxesaround the figure that represent the main concept.

5.1.3 Example

In figure 3 we can see an example which illustrates the concrete syntax witha process of a company that makes bread, is a simplify version of the systemwith only one type of product. This example is taken from [17]. The generalproduction system can be explained in the nest steps:

1. Formulation: The process begins when the worker in charge of the mixtureadd the raw material and the special ingredients of the type of bread thatthey are going to produce.

2. Mixture: At the end of step 1 the mixture process begin, as a result ofthis process we obtain a raw mass. The processing time of this operation

18 5.2. Syntax Restrictions

Figure 5.2 Concrete Syntax

depends on the type of mass.

3. Mass growth: The raw mass is put to rest for 30 min, the objective of thisstep is for the mass to grow.

4. Mass flatten: In this step a machine gives the final texture required forthe mass. The processing time of this step is of 6 minutes.

5. Cut and bread form: In this step the mass is cut and depending on thetype of bread they are making they give a certain form. Depending on thetype this process is manual or automatic. For the purpose of this examplewe considered an automatic approach.

6. Bread Growth: In this step the bread is taken to a room with an specialenvironment to let it grow.

7. Baked: In this step the bread is baked in one of the ovens that the companyhas.

8. Cooling: In this step they wait 30 minutes for the bread to cool down.

9. Bread Packing: In this step the bread is packed and stored.

5.2 Syntax Restrictions

This language have the following restrictions in the use of its concepts.

1. A sub-net most have one input condition element.

2. A sub-net most have one output condition element.


Figure 5.3 Example

3. A input condition can not have input arcs.

4. A input condition most have one output arc.

5. An atomic task most have one input arc.

6. An atomic task most have one output arc.

7. A multiple instance task most have one input arc.

8. A multiple instance task most have one output arc.

9. A composite task most have one input arc.

10. A composite task most have one output arc.

11. A lag task most have one input arc.

12. A lag task most have one output arc.

13. A trigger most have one input arc.

14. A trigger most have one output arc.

15. An and join can have more than one input arc.

16. An and join most have one one output arc.

17. A xor join can have more than one input arc.

18. A xor join most have one one output arc.

19. An and split most have one input arc.

20. An and split can have more than one output arc.

21. A xor split most have one input arc.

22. A xor split can have more than one output arc.

23. Is not allowed a transition between two xor splits.

24. Is not allowed a transition between two xor joins.

20 5.3. Transformations Rules

25. Is not allowed a transition between two and split.

26. Is not allowed a transition between two and joins.

27. Is not allowed a transition having an input condition at the end of it.

28. Is not allowed a transition with an output condition at the beginning of it.

29. Is not allowed a transition between an and split and a xor join.

30. Is not allowed a transition between an and split and a xor split.

31. Is not allowed a transition between an and split and an and join.

32. Is not allowed a transition between a xor join and an and split.

33. Is not allowed a transition between a xor join and an and join.

34. Is not allowed a transition between a xor join and a xor split.

35. Is not allowed a transition between a xor split and a xor join.

36. Is not allowed a transition between a xor split and an and split.

37. Is not allowed a transition between a xor split and an and join.

38. Is not allowed a transition between an and join and an and split.

39. Is not allowed a transition between an and join and a xor split.

40. Is not allowed a transition between an and join and a xor join.

5.3 Transformations Rules

One of our objectives of this work is to use the solution schema worked on PetriNets. Specifically the work of Juan Pablo caballero [4] where he give a factiblesolution to the scheduling problem by means of a genetic algorithm on the Petrinet. This is the reason to create some transformation rules from the work-flowconcepts defined in our proposed language to the petri net concepts. In thefollowing section we will explain this rules of transformation in more detail.

5.3.1 Independent Input Condition

In figure 4 we can see the transformation of an independent input condition toPetri net concepts. It consists in a timed place (place with time zero or differentdepending on the release time) with 0 to n initial tokens (number of initial parts),connected with a transition (where it receive the tokens from triggers) and thetransition connected with another immediate place.

Figure 5.4 Transformation for independent Input Condition


5.3.2 Output Condition

In figure 5 we can see the transformation of an output condition to Petri netconcepts. It consists in a transition, a immediate place with no tokens and anarc between them.

Figure 5.5 Transformation for Output Condition

5.3.3 Resource

In figure 6 we can see the transformation of a resource to Petri net concepts. Itconsists in a place with one token.

Figure 5.6 Transformation for Resource

5.3.4 Atomic Task - Setup Time = 0 and Percent Completion= 100

In figure 7 we can see the transformation of an atomic task with a setup timeof zero and a percent of completion of 100 to Petri net concepts. It consists ina transition connected with a timed place (place with time different to zero),this timed place connected with another transition and this transition connectedwith an immediate place (place with time zero) .

Figure 5.7 Transformation for Atomic Task

In figure 8 we can see the transformation of a the same atomic task withan associated resources. It consists in the two transformations of resource andatomic task with two additional transitions. The first one from the place of theresource to the initial transition of the atomic task. The second one from thefinal transition of the atomic task to the place of the resource.

Figure 5.8 Transformation for a Atomic Task with a resource


5.3.5 Atomic Task - Setup Time = 0 and Percent Completion <100

In figure 9 we can see the transformation of an atomic task with a setup timeof zero and a percent of completion below 100 to Petri net concepts. It consistsin a transition connected with a timed place (place with time of the percentof completion times the processing time - PART A), this timed place connectedwith another transition. This transition connected with an immediate final place(place with time zero) and connected with another timed place that correspondswith the rest of the processing time (PART B). And this last timed place isconnected to a transition(connected to the resource) and this transition to aimmediate place.

Figure 5.9 Transformation for a Atomic Task - Setup Time = 0 and Percent Completion< 100 with resource

5.3.6 Atomic Task - Non Anticipated Setup Time > 0 and Per-cent Completion = 100

In figure 10 we can see the transformation of an atomic task with a non antici-pated setup time different from zero and a percent of completion equals to 100.It consists in a transition connected with a timed place (place with setup time),this timed place connected with another transition. This transition connectedwith another timed place that corresponds with the processing time of the task.And this last timed place is connected to a transition (connected to the resource)and this transition to a immediate final place.

Figure 5.10 Transformation for a Atomic Task - Non Anticipated Setup Time > 0 andPercent Completion = 100 with resource

5.3.7 Atomic Task - Non Anticipated Setup Time > 0 and Per-cent Completion < 100

In figure 11 we can see the transformation of an atomic task with a non antici-pated setup time different from zero and a percent of completion equals to 100.It consists in a transition connected with a timed place (place with setup time),this timed place connected with another transition. This transition connected


with another timed place that corresponds with the processing time times thepercent of completion (PART A) of the task. The timed place is connected toa transition that is connected with an immediate final place (place with timezero) and connected with another timed place that corresponds with the restof the processing time (PART B). And this last timed place is connected to atransition(connected to the resource) and this transition to a immediate place.

Figure 5.11 Transformation for a Atomic Task - Non Anticipated Setup Time > 0 andPercent Completion < 100 with resource

5.3.8 Atomic Task - Anticipated Setup Time > 0 and PercentCompletion = 100

In figure 12 we can see the transformation of an atomic task with an anticipatedsetup time and a percent of completion equals to 100. It consists in a transitionconnected with a timed place (processing time), this time is connected with atransition and then with a immediate place. The setup time is represented withthe transition and timed place that are connected with the place of the resource.As we can see the setup time can be done before the task begins.

Figure 5.12 Transformation for a Atomic Task - Anticipated Setup Time > 0 and PercentCompletion = 100 with resource

5.3.9 Atomic Task - Anticipated Setup Time > 0 and PercentCompletion < 100

In figure 13 we can see the transformation of an atomic task with an anticipatedsetup time different from zero and a percent of completion below 100 to Petrinet concepts. It consists in a transition connected with a timed place (placewith time of the percent of completion times the processing time - PART A),this timed place connected with another transition. This transition connectedwith an immediate final place (place with time zero) and connected with anothertimed place that corresponds with the rest of the processing time (PART B). Andthis last timed place is connected to a transition(connected to the resource) andthis transition to a immediate place. The setup time is represented with thetransition and timed place that are connected with the place of the resource.


Figure 5.13 Transformation for a Atomic Task - Anticipated Setup Time > 0 and PercentCompletion < 100 with resource

5.3.10 Transition

The transition transformation consists in making an arc between the last placeof the transformation of the source object and the first transition of the trans-formation of the target object. As we can see in figure 14.

Figure 5.14 Transformation for a Transition

As an example in figure 15 we can see the transformation of transition be-tween two Atomic Task connected with a transition. As we can see the last placeof the first atomic task is joined with an arc with the first transition of the secondatomic task.

Figure 5.15 Transformation for a Transition between two Atomic Task

5.3.11 Trigger

In figure 16 we can see the transformation of a trigger. It consists in in atransition, a immediate place with no tokens and an arc between them. Theplace is connected (arcs) with all the transitions of the input conditions thatthis element has associated. This connection consists in an arc that connects thetransition of the trigger transformation with the first place of the transformationof the input condition.

Figure 5.16 Transformation for a trigger


5.3.12 Multiple Instance task

In figure 17 we can see the transformation of a multiple instance task, this elementonly has two instances. It consists in transition connected with a immediateplace. This place is connected with all the initial transitions of the instance ofthe task. For every instance we have a initial transition connected with a timedplace, and the timed place connected with a final transition. And each of thefinal transition of the instance of task is connected to a final immediate place.Each instance can have a different processing time, a different resource, a setuptime (anticipated or non anticipated) and a percent of completion.

Figure 5.17 Transformation for a multiple instance

5.3.13 And Join

In figure 18 we can see the transformation of an and join, the transformationof the and join is basically a transition connected with a non timed place. Toconnect this transformation with a previous elements like B and C we have todraw an arc from the last place of the transformation of B to the transition ofthe and join, and from the last place of the transformation of C to the transitionof the and join. And to connect this transformation with a posterior element likeA we have to connect an arc from the place of the and join to the first transitionof the transformation of A.

Figure 5.18 Transformation for and join

5.3.14 And Split

In figure 19 we can see the transformation of an and split, the transformation isbasically a transition. To connect this transformation with a previous elementlike A we have draw an arc from the last place of A with the transition of the andsplit. And to connect this transformation with posterior elements like B or C wehave to draw an arc from transition of the and split to a new place(simultaneousstart) and then draw another arc from this place to the first transition of the


transformation of B. And the same thing with C draw an arc from the transitionof the and split to a new place(simultaneous start) and then draw another arcfrom this place to the first transition of the transformation of C.

Figure 5.19 Transformation for and split

5.3.15 Xor Join

In figure 20 we can see the transformation of a xor join, the transformationis basically a non-timed place. To connect this transformation with previouselements like B and C, we draw an arc from the last place of B to a new transition(only one task needs to finish to start the next one) and then draw another arcfrom this transition to the place of the xor join. And the same thing with Cdraw an arc from the last place of C to a new transition (only one task needsto finish to start the next one) and then draw another arc from this transitionto the place of the xor join. To connect this transformation with a posteriorelement like A we have to draw an arc from the place of the xor join to the firsttransition of the transformation of A.

Figure 5.20 Transformation for xor join

5.3.16 Xor Split

In figure 21 we can see the transformation of the xor split, the transformationis basically a transition connected with a non-timed place. To connect thistransformation with a previous element like A we have to draw an arc from thelast place of the transformation of A to the transition of the xor split. To connectthis transformation with posterior elements like B and C we have to draw an arcfrom the place of the xor split to the first transition of the transformation of Band also and we draw an arc from the place of the xor split to the first transitionof the transformation of C.


Figure 5.21 Transformation for xor split

5.3.17 Lag

In figure 22 we can see the transformation of the lag task, the transformationconsist in a transition connected with a timed place. The lag is a time that noresource process, the input parts are how many parts pass through the lag, inthe transformation the input parts are the weight of the arcs that comes to thetransition of the transformation and the arc that goes from the transition to thetimed place.

Figure 5.22 Transformation for lag task

5.3.18 Composite Task

The composite concept is a phantom concept, it doesn’t have an actual trans-formation. The only transformation are the arcs that this concept has with aprevious element and with a posterior element. The arc with the previous ele-ment corresponds to an arc between the last place of the transformation of theprevious element and the first transition of the transformation of the input taskof the sub-net which the composite task references. And the arc with the poste-rior element corresponds to an arc between the last place of the transformationof the output condition of the sub-net which the composite task references andthe first transition of the transformation of the posterior element.

6Case Style

This chapter is divided in different sections, in each of them we introduce a seriesof concepts of the proposed language, we illustrate how to use this concepts torepresent a specific manufacture system and how they are transformed to a Petri-net.

6.1 Sequential manufacture systems

6.1.1 Process to manufacture a shovel

Assume in this example that we have all the parts that are needed to manufacturea shovel. The tasks of manufacturing process are:

1. Support of the handgrip assembly: This task is made by a worker and ismade in a period of 15 minutes. This task is independent from others.

2. HandGrip assembly: This task is made by a worker and it consists inputting together the support of the handgrip with the handgrip. This taskis made in a period of 15 minutes. Before performing this task is necessaryto finish the assembly of the support of the handgrip.

3. Scoop assembly: This task is made by a worker and it consists in puttingtogether the parts that conform the scoop of the shovel. This task is madein a period of 20 minutes. This task is independent from others.

4. Shovel assembly: This task is made by a worker and consists in puttingtogether the handgrip and the scoop. Before performing this task is nec-essary to finish the handgrip assembly and the scoop assembly. This taskis made in a period of 20 minutes

6.1.2 Simple sequence

Lets assume that we only have a worker and we have to make the process, eachtask after the other (1-2-3-4). The associated representation using the proposedlanguage is shown in Figure 7.1.

29

30 6.1. Sequential manufacture systems

Figure 6.1 Simple Sequence Process

Taking into account the transformation rules of the last chapter, the associ-ated Petri-net of this process is shown in Figure 7.2.

Figure 6.2 Transformation for a Sequential Process

6.1.3 And Join/Split

Now lets assume that we have another worker and we can make tasks in parallel.In the process of making the shovel the only task that can be performed in parallelis the scoop assembly because it is independent from others. The handgripassembly goes always after the assembly of its support. And the shovel assemblygo after all the operations. The associated representation for this process isshown in Figure 7.3.

Figure 6.3 Parallel Process

As we can see the element and split let us start a series of tasks in parallel,and the and join let us wait for a series of tasks to finish before beginning thenext task. In this case the shovel assembly depend of both the scoop and thehandgrip assembly. Taking into account the transformation rules of the lastchapter, the associated Petri-net of this process is shown in Figure 7.4.

6.1.4 Xor Join/Split

Lets add a new task to our manufacture process Paint the shovel, this task ismade by a worker and consist in painting the shovel with a determined color

Case Style 31

Figure 6.4 Transformation for Parallel Process

(red, blue or yellow). But a shovel only can be painted with one color, thereforeexists three different tasks Paint the shovel blue, Paint the yellow and Paintthe shovel red. The shovel only passes for one of this tasks. This task can onlybe performed after the shovel assembly.

With this new addition the associated representation for this process is shownin Figure 7.5

Figure 6.5 Optional Process Example

As we can see the element xor split let us start one of a series of tasks, and thexor join let us wait for only one of the previous tasks to begin with the next task.In this particular case when one of the painting process finish the manufacturesystem ends. Taking into account the transformation rules of the last chapter,the associated Petri-net of this process is shown in Figure 7.6.

Figure 6.6 Transformation for Optional Process Example

6.2 Resources

As we expect each of this tasks have a resource (machine or person) that performthe specific activity. Lets return to the example of Figure 7.1 where exist only oneresource that is shared among the 4 tasks. The complete diagram that representthis system is shown in figure 7.7. The link between the task and the resource isdone in the properties of the task where we can choose over the resources of thesystem. As we can see the system is separated in two the first part is form theresource of the system and the second parts are for the sub-nets that representthe different processes of the system.

32 6.3. Multiple instance tasks

Figure 6.7 Resource Example

Taking into account the transformation rules of the last chapter, the associ-ated Petri-net of this process with the addition of the resource is shown in Figure7.8.

Figure 6.8 Resource Transformation Example

6.3 Multiple instance tasks

In this section we will introduce a new type of task, the multiple instance task.Lets return to the example of the section 7.1, lets assume that the system hastwo workers and that the task Hand Grip Assembly and Shovel Assembly canbe made by either one of them, but we now that the worker 1 can finish theHand Grip Assembly in 20 minutes and the worker 2 in 15 minutes. For theShovel Assembly the the two workers performed it in 20 minutes. To representthis kind of tasks we can use the xor join/split of section 7.1.4 or we can usethe multiple instance task(compact and easier form). A multiple instance taskcan have several instances and for each of this ones we can specify the resourceand the processing time. The diagram for this manufacture system is shown inFigure 7.9. As we can see the instances are the little boxes beneath the task.

Taking into account the transformation rules of the last chapter, the associ-ated Petri-net of this manufacture system is shown in Figure 7.10.

Case Style 33

Figure 6.9 Multiple Instance Example

Figure 6.10 Multiple Instance Example Transformation

6.4 Subprocesses

In this section we will introduce two concepts to reference another process. Thecomposite task and the trigger, the composite task let us express that a processis composed of smaller processes that are linked together in an other, for exampleif we have to manufacture a pen, first we have to manufacture the ink then thebody and then the head of the pen. Lets assume that making the body is morecomplex and has associated a manufacture process, with this concept we canexpress this.

The trigger let us express that in a step of the manufacture we can start inparallel another process. For example in making bread after taking the breadout of the oven we can pack the bread but also we can star with the next typeof bread. This means that the process of making the next type of bread can bedone in parallel with the packing of the previous type of bread.

34 6.4. Subprocesses

6.4.1 Composite Task

Lets return to the example of Figure 7.1 where exist only one resource that isshared among the 4 tasks. Lets assume that the Hand Grip Assembly is a morecomplex process that consist in the following tasks:

• Join support and hand grip with nails: This task is made by a worker, ittakes among 7 minutes to finish it.

• Apply Glue: This task is made by a worker, it takes among 5 minutes tofinish it. This task goes after the joining the support and the hand gripwith nails.

• Dry of the piece: This tasks is made by a worker, it takes among 7 minutesto finish. This task goes afters applying the glue.

The diagram for this manufacture system taking into account this new processfor the hand grip assembly is shown in Figure 7.11. In the figure is not clearhow the relationship between the sub-nets, in the properties are for the compositetask there is a reference to a sub-net, and this is where we specify the subprocess.

Figure 6.11 Composite Example

Taking into account the transformation rules of the last chapter, the as-sociated Petri-net of this manufacture system is shown in Figure 7.12. Thetransformation of the box represents the transformation for the subprocess.

6.4.2 Triggers

Lets return to the example of Figure 7.1 where exist only one resource that isshared among the 4 tasks. Lets assume between the scoop assembly task and theshovel assembly we can perform in parallel the assembly of other kind of shovelthe following three steps(with another worker specialized to make this kind ofshovel):

Case Style 35

Figure 6.12 Composite Example Transformation

• Scoop Assembly: Different from the other type of shovel, the hand grip ismade from plastic and we don’t need to build it up. This tasks is made bya worker and consists in putting together the parts that conform the scoopof the shovel. This task is made in a period of 25 minutes.

• Shovel Assembly: This task is made by a worker and consists in puttingtogether the handgrip and the scoop of the shovel.This task is made in aperiod of 15 minutes.

• Chrome painting: This task is made by a machine and consists in paintingthe shovel with a chrome ending.This task is made in a period of 15 minutes

The diagram for this manufacture system taking into account this new typeof shovel is shown in Figure 7.13. In the properties of the trigger concept wecan add various input conditions that we want to start in the desire point of thesystem.

Figure 6.13 Trigger Example

Taking into account the transformation rules of the last chapter, the associ-ated Petri-net of this manufacture system is shown in Figure 7.14.

36 6.4. Subprocesses

Figure 6.14 Trigger Example Transformation

7Implementation

In this chapter we describe the different tools we implemented for this work (setof plugins for eclipse IDE).

7.1 Language and editor

The metamodel of the proposed language was develop in EMF. We define syntaxrestrictions for this metamodel with OCL (for more information go to chapter2) to help the modeler verify what he can do with the language. The editor forthis language was develop with Eugenia, Eugenia let use generate plugins forthe editor, language and tests over them. The figures used on the editor thatrepresent each of the concepts defined on the concrete syntax are implementedin another plugin of eclipse.

7.2 Transformation

For the transformation from the MoLde concepts to the Petri-net concepts wasimplemented in ATL. We also develop a plugin that adds an option to the eclipseIDE menu to execute this transformation and generate the model of the Petri-netin the eclipse selected workspace.

7.3 Other generated files

In the plugin that executes the transformation we develop a function that receivesas input the generated model of the Petri-net and generate two files. The firstfile is a file for a toolkit of Petri-nets (TINA) that lets us visualize the generatedPetri net, execute some structural analysis and use a step simulation in thePetri net. We can clarify that all the characteristics of the generated Petri-netare not present in the tina file, in specific the times of the transitions becausethis toolkit don’t support this characteristic. The second file is a CSV file witha matrix representation of the generated Petri-net. This file is structured asfollows

37

38 7.4. How to use the plugins?

This CSV file is used as input for the genetic algorithm defined by Juan Pablocaballero in [4].

7.4 How to use the plugins?

1. Create an empty project en eclipse. Name the new project.

Figure 7.1 Create Empty Project

Figure 7.2 Name New Project

Implementation 39

2. Create a manufacture system diagram. Name the new diagram.

Figure 7.3 Create New Diagram

Figure 7.4 Name New Diagram

Figure 7.5 Diagram Created


3. Model the desire manufacture system with the proposed language.

Figure 7.6 Model Manufacture System

4. Validate syntax of the diagram.

Figure 7.7 Validate Syntax

5. Execute the transformation.

Figure 7.8 Execute Transformation

Three files are generated. CSV files, TINA file and petri-net model.

Implementation 41

Figure 7.9 Result Transformation

6. Check the generated Petri-net with TINA.

Figure 7.10 Open TINA file

Figure 7.11 Tools of analysis TINA

8Validation

In this chapter we describe the validation process that consists in two parts. Thefirst part is to check the transformation rules to the Petri-net with the purposeof checking the formation of the result Petri-net. This first part of the processwe receive help of an expert in Petri-nets.

The second part was to model a set of manufacture systems with the proposedlanguage to see the expressive capability of the concepts. In this section of thischapter we show a couple of examples. And at last we ask help of some industrialengineers (PyLO research groups) to use the proposed language with the developtools to be able to have external retrospective over the solution. This processhelp improve the tools and the proposed language.

8.1 Transformation Rules Validation

In this part of the validation we consult an expert on Petri-nets to extend thetransformation rules for the new concepts we want to include in the language.After the implementation of this new rules we created basic examples with theproposed language, this examples had a valid syntax so we can execute thetransformation rules. Then we took the Tina file generated and use the toolsof TINA to make structural analysis, step simulations, and check visually thePetri-net. We make a lot of this iterations validation different rules, rules forconcepts or rules for the arcs between them.

8.2 Language Expressiveness Validation

In this section we introduce two examples that we use two validate the expres-siveness of the language. The first example was used at the beginning of theproject to look for new concepts, and see the transformation rules of the basicones. The second example was used at the end of the project, its described in[23]. This last one is a really complex manufacture system because of the amountof restrictions are present in it.

43

44 8.2. Language Expressiveness Validation

Figure 8.1 TINA Petri-net

Figure 8.2 TINA TINASimulator

8.2.1 Fabrication of injection moulds

For the first part of the project we choose among the diversity of complex man-ufacturing systems, the ones whose main goal is the production of tools for thefabrication processes in other industries. Such is the case of the fabrication ofinjection moulds, which is a support industry for almost all companies that useinjected components either as final product or as semi-finished products. In [5]the authors uses Petri-nets and genetic algorithms to describe and optimise theproduction environment.

We validate the proposed solution with the one of the authors of [5]. We beginmodeling a small instance of the manufacture system that fabricates injectionmoulds with a Petri-Net. The result is shown in the figure 15.

Figure 8.3 Initial Petri Net

Validation 45

The next step was to model the same instance with the proposed language,to test the expressive capability of the proposed languages. The result is shownin figure 16.

Figure 8.4 Problem instance using proposed language

In this point we can see the benefits of the proposed language, is really simpleto model a system with this language. The result representation is simple andeasy to manipulate.

Then next step was to validate the generated Petri-net with the originalone(figure 15). The generated Petri-net is shown in figure 17.

Figure 8.5 Generated Petri Net

Although the associated Petri-net is bigger than the original one, the two netsare equivalent and we are not changing the behaviour of the original system. Inthe transformation we add some transitions and places to make it easier to definethe transformation rules. During this process we add the concept trigger.

8.3 Ceramic Tile production

8.3.1 Case of Study

This case of study deals with a specific scheduling system in the Spanish ceramictile sector. The fist step of the process is the molding where the atomized clay

46 8.3. Ceramic Tile production

powder is loaded into molds (here is where the fluidity of the atomized clay playsan important role) and it is pressed by large hydraulic presses to form what iscalled the bisque. This process is very important as all further operations dependon the correct formation of the tile. The physical dimensions of the tile, oftenreferred to as the format of the tile, depend on the characteristics of the moldemployed. Additionally, the visible side of the tile might not be entirely flat asit might have a ‘stone-like’ pattern. This is determined by the plate of the mold.

Right after molding, the bisques are quite fragile and should undergo furtherdrying. This process is usually carried out in either vertical or horizontal dryers(small kilns). After drying, the bisque is hardened to what resembles a chocolatebar and therefore, can withhold further processing operations. The bisque orceramic tile is then decorated in the glazing lines. Some specific products arenot glazed, however, this is not very common. In a glazing line, tiles move overconveyor belts and different applications, decorations and other operations areperformed over them. The most basic operation is the application of the baseglaze by simple bell or waterfall machines to advanced random rotary decora-tions, referred to as rotocolors. Modern glazing equipment includes ‘printers’which can basically print ceramic tiles with a large array of colours, patternsand decorations. Glazing lines can contain more than 50 different machines andcan be up to 50m long, sometimes even more. The different glaze applicationsdetermine the style, colour, surface and characteristics of the tile.

Decorated bisques are stored in big boxes or ‘roller stillages’ that containmany roller planes where bisques are fed into, stored and extracted from at laterstages. The big boxes are transported from the glazing lines to an intermediatestorage area by automated guided vehicles (AGVs).

The central stage of the production process is the single kiln firing. Ceramickilns are large horizontal ovens with usually a single plane of rollers that movein one direction, advancing the glazed bisques through the different stages. Eachtype of clay and tile follows a different temperature curve inside the kiln. Thistemperature might be also affected by the physical size or format of the tile.A number of physical and chemical reactions undergo inside the kiln to form ahardened and finished tile. Most notably, the glaze fuses and hardens on top ofthe tile, conferring most known and desired characteristics of ceramic tiles.

Summary

We can summary the stages of this manufacture system in 3.

1. Mold and Drying: Have two machines that can perform this task.

2. Glaze: Have two machines that can perform this task.

3. Single kiln firing Have two machines that can perform this task.

Additional Restrictions for the stages

• Each stage has m parallel machines that are unrelated. Meaning that theprocessing time for a job depends on the machine it has been assigned to.

• Stages has setup times (time to prepare the machine an depends on thejob the machine is assigned to). An example of this is when the productionof a given ceramic tile with a format of 33 × 33 cm. is finished, a very

Validation 47

large setup time is needed if the next batch of tiles to produce in that samemold has a different format, like for example 60×60 cm. Large portions ofthe molding machine have to be disassembled, several adjustments mustbe done and all this usually takes up to a full working shift.

• Not every possible job might be processed on every possible machine(Thisis known as machine eligibility). Once again, a clear example comes fromthe molding presses. Large tile formats like 60×120 cm. often requirespecial molding presses with pressing forces in excess of 45.000 kN.

• Setup times can be anticipatory or non-anticipatory. As the name implies,an anticipatory setup time, for example a cleaning, can be done in thecorresponding machine as soon as the machine is free without actuallywaiting for the next job in the sequence to arrive. However, some setupson machines might require the jobs to be already present on the machine(i.e. fixing the product to be processed on the machine) and are thereforenon-anticipatory.

• Production floors are seldom found empty. When doing real scheduling,machines are at a given moment processing materials. This means thatnew schedules must start after existing jobs are finished. Therefore, stagescan have release date of machine. This date indicates when the machine isreleased from previous work and can start processing new jobs.

• A job, defined before as a batch of tiles does not need to be fully glazedbefore entering the kiln. A large production batch of tiles might needseveral days of glazing and several days of kiln firing. Batches are madeout of thousands of tiles. This means that when a sufficient quantity of tileshave been glazed, these can already enter the kiln while the remaining lot isbeing glazed. This effectively represents an overlap between operations. Insome other situations, we have a waiting time in between stages for a givenbatch. Some special glazes require an ‘air drying’ time before enteringthe kiln. As a result, we might have overlaps and/or waiting times.Theoverlaps receive the name of negative lag and the waiting times receive thename of positive lags.

We didn’t include the data tables of the problem but if you want to checkthem look chapter 15 of [23].

Jobs

The system has two make 5 jobs. Each job has two complete different stagesand depending on the job it can use certain machines in each stage (MachineEligibility).

Job 1: Process

1. Molding and Drying (M1 or M2)

2. Glaze (M4)

3. Single kiln firing (M5)


Job 2: Process


2. Glaze (M3 or M4)

Job 3: Process

1. Glaze (M3)


Job 4: Process

1. Molding and Drying (M2)


Job 5: Process


2. Glaze (M3 or M4)


Also we now that jobs 4 and 5 are preceded by jobs 2 and 3.

8.3.2 Model

In this section we will show you how we model this problem with the proposedlanguage. In the figure 9.6 we can see the complete model for this problem. Wecan see that the system is represented by a big box that is divided in two sections.The first section is where the modeller define the machines of the system andthe second section is where the modeller describe the sub processes.

In Figure 9.7 we can see the first section where we define the 5 machinespresent in the system.

Because each job has a different process and uses different machines in thestages, we need to model them in different sub processes. In figure 9.8 we cansee the process to make the first job, it begins with molding and drying and canbe used M1 or M2, then it continues with Glaze with M4 and at last we havethe single kiln firing with M5. After the molding and drying stage we have apositive lag before beginning with the glaze stage. In this figure we can also seethe forms that we fill with the attributes of input task concept, the atomic taskconcept and the lag concept. The concept with more properties is the atomictask where you specify the resource, the processing time, the anticipatory setuptime, the non-anticipatory setup time, among others.

In figure 9.9 we can see the model of the process to make the second job, itbegins with the molding and drying stage using either M1 or M2, and it continueswith the glaze stage using either M3 or M4. After the molding and drying stageusing only the machine 1 we have a positive lag before beginning the next stage.We include a lag concept with processing time 0 between the join of stage 1 and

Validation 49

Figure 8.6 Complete model for the ceramic tile production problem

Figure 8.7 Resource section for the ceramic tile production problem

Figure 8.8 Process for Job 1

the split of the stage 2 because exist a restriction that says that a split and ajoin can be joined together with a transition.

In figure 9.10 we can see the model of the process to make the third job and



fourth job. For the third job first it starts in the glaze stage with the M3 thenwe have a positive lag before beginning the stage of single kiln firing with M5.For the fourth job it starts in the molding and drying stage with M2 then wehave a positive lag before beginning the stage of single kiln firing with M5.

Figure 8.10 Process for Job 3 and Job 4

In figure 9.11 we can see the model of the process to make the fifth job. Itbegins with the molding and drying stage with either M1 or M2, the the glazestage with either M3 or M4 and finally the single kiln firing with M5. We havea positive lag when using M4 in the glaze stage with this job.


In figure 9.12 we can see the model of the job precedence. Before we can dothe job 4 and job 5 we need to do job 2 and job 3. This means that we can do

Validation 51

job 2 and job 3 in parallel if we have the sufficient resources and then we canmake job 4 and job 5 in parallel. The job1 doesn’t have any restriction. In thisfigure we can see the properties section for the composite task concept where wecan select the sub process that correspond to this task.

Figure 8.12 Job Precedence

8.3.3 Transformation and Analysis

Now that we have the model of the manufacture system we can transform itto Petri-net. And with the Tina file we can execute some analysis over thegenerated Petri-net. In figure 9.13 we show the generated Petri-net and someanalysis using TINA toolbox.

Figure 8.13 Generated Petri-net

9Conclusions and Future Work

In this project we presented a workflow language to help with the modellingprocess of a manufacture systems. This language has concepts really close tothe ones used to describe a manufacture system, making it easier to describe amanufacture system than the methodologies used today discussed in [6]. Withthis language we can express the control flow of the tasks, the definition ofresources in the system and its relationship with the tasks, and some restrictionsbetween the tasks, resources and jobs. We also describe the tools we develop touse this language and generate the associated Petri-net, we introduce a Petri-net toolbox (TINA) to help visualize and run some analysis over the generatedPetri-net.

In the validation process we validate with an expert on Petri-net the trans-formation rules used on the project. Also expressed difficult manufacture sys-tems(amount of restrictions included in the system) using the proposed languageto test the expressiveness of the language. And at last we ask help of some in-dustrial engineers (PyLO research groups) to use the proposed language withthe develop tools to be able to have external retrospective over the solution.

Future work will be focused in integrating more concepts of manufacturesystems to the language to make it more complete. Also to be able to integratefiles into a diagram, this means be able to describe a system with a diagram andinclude that system into other diagram. And for the transformation schema tobe able to transform the proposed language to different structures no only usingPetri-net.

53

Bibliography

[1] C. BASNET. Technical note: Tabu search heuristic for a loading prob-lem in flexible manufacturing systems. International Journal of ProductionResearch, 34(4):1171–1174, 1996.

[2] D. Borenstein. A directed acyclic graph representation of routing manufac-turing flexibility. European Journal of Operational Research, 127(1):78 – 93,2000.

[3] P. Brandimarte. Routing and scheduling in a flexible job shop by tabusearch. Annals of Operations Research, 41(3):157–183, 1993.

[4] J. P. Caballero and G. Mejıa. Redes de petri y algoritmos geneticos, unapropuesta para la programacion de sistemas de manufactura flexible. Inge-nieria y Universidad, 10(1), 2010.

[5] J. Caballero-Villalobos, G. Mejıa-Delgadillo, and R. Garcıa-Caceres.Scheduling of complex manufacturing systems with petri nets and geneticalgorithms: a case on plastic injection moulds. The International Journalof Advanced Manufacturing Technology, 69(9-12):2773–2786, 2013.

[6] F. T. S. Chan and J. Zhang. Modelling for agile manufacturing systems.International Journal of Production Research, 39(11):2313–2332, 2001.

[7] W. V. der Aalst and A. H. M. T. Hofstede. Yawl: Yet another workflowlanguage. Information Systems, 30:245–275, 2003.

[8] P. Fattahi, M. Saidi Mehrabad, and F. Jolai. Mathematical modeling andheuristic approaches to flexible job shop scheduling problems. Journal ofIntelligent Manufacturing, 18(3):331–342, 2007.

[9] D.-C. Gong and Y.-W. Hsieh. Conceptual design of a shop floor controlinformation system. International Journal of Computer Integrated Manu-facturing, 10(1-4):4–16, 1997.

[10] Y. Ito. Similarity evaluation for flexible manufacturing cell: An interestingapplication of graph theory to manufacture. In Y. Ito, editor, Thought-Evoking Approaches in Engineering Problems, pages 213–230. Springer In-ternational Publishing, 2014.

[11] P. K. Jain. Solving resource contention problem in fms using petri netsand a rule-based approach. International Journal of Production Research,39(4):785–808, 2001.

[12] P. Kellert, N. Tchernev, and C. Force. Object-oriented methodology for fmsmodelling and simulation. International Journal of Computer IntegratedManufacturing, 10(6):405–434, 1997.

54

Bibliography 55

[13] D. Y. Lee and F. DiCesare. Scheduling flexible manufacturing systems usingpetri nets and heuristic search. Robotics and Automation, IEEE Transac-tions on, 10(2):123–132, 1994.

[14] L. Lenart and A. Ruzic. Scheduling in flexible manufacturing systems,supported through cyclic net analysis. In P. Kopacek, editor, Robotics inAlpe-Adria Region, Schriftenreihe der Wissenschaftlichen Landesakademiefur Niederosterreich, pages 178–182. Springer Vienna, 1994.

[15] M. Mujica Mota and M. A. Piera. An improved time line search algorithmfor manufacturing decision-making. International Journal of ProductionResearch, 52(4):1116–1132, 2014.

[16] T. Murata. Petri nets: Properties, analysis and applications. Proceedingsof the IEEE, 77(4):541–580, 1989.

[17] C. Ortiz Morales, E. Gutierrez Garcıa, and J. Cardona Giraldo. Analisis ymejoramiento del proceso de produccion Industria Panificadora Suprema /Carolina Ortiz Morales ; director, Eliecer Gutierrez Garcıa ; jurado, JulianCardona Giraldo. Tesis (Ingeniero Industrial). Universidad de los Andes.Bogota : Uniandes, 2012., 2012.

[18] T. Y. Park, K. H. Han, and B. K. Choi. An object-oriented modellingframework for automated manufacturing system. International Journal ofComputer Integrated Manufacturing, 10(5):324–334, 1997.

[19] R. P. Parker and A. Wirth. Manufacturing flexibility: Measures and rela-tionships. European Journal of Operational Research, 118(3):429–449, 1999.

[20] N. Russell, A. ter Hofstede, W. van der Aalst, and N. Mulyar. Workflowcontrol-flow patterns: A revised view. Technical Report BPM-06-22, BPMCenter, 2006.

[21] K. Saitou, S. Malpathak, and H. Qvam. Robust design of flexible manufac-turing systems using, colored petri net and genetic algorithm. Journal ofIntelligent Manufacturing, 13(5):339–351, 2002.

[22] M. K. Tiwari, M. Chandrasekaran, and R. P. Mohanty. Use of timed petrinet and activity cycle diagram methodologies for modelling tandem agvs infmss and their performance evaluation. International Journal of ComputerIntegrated Manufacturing, 14(4):399–408, 2001.

[23] J. Torres, J. Framinan, R. Leisten, and R. Garcıa. Manufacturing Schedul-ing Systems: An Integrated View on Models, Methods and Tools. SpringerLondon, 2014.

[24] W. Xia and Z. Wu. An effective hybrid optimization approach for multi-objective flexible job-shop scheduling problems. Computers & IndustrialEngineering, 48(2):409 – 425, 2005.

[25] G. Zhang, X. Shao, P. Li, and L. Gao. An effective hybrid particle swarmoptimization algorithm for multi-objective flexible job-shop scheduling prob-lem. Computers & Industrial Engineering, 56(4):1309 – 1318, 2009.

56 Bibliography

[26] A. Zimmermann. Modeling and evaluation of stochastic Petri nets withTimeNET 4.1. 2012.

molde: a workﬂow language for the modelling of manufacture

Documents