Manzone Nervi Thesis

Politecnico di Milano
Scuola di Ingegneria Industriale e dell'Informazione
Corso di Laurea in Ingegneria Gestionale

Energy Efficient Policies for a

Self-aware Job Shop Production
System

Supervisor: Prof. Marco Taisch
Co-supervisor: Ing. Claudio Palasciano

Thesis by:
Valeria Manzone 819332
Cecilia Nervi 818649
Academic Year 2015-2016

Summary
ABSTRACT ..................................................................................................................................... XI
ABSTRACT .................................................................................................................................. XIII
EXECUTIVE SUMMARY ........................................................................................................... XV

I. General Context ............................................................................................................. XV
II. Thesis Aim and Structure ............................................................................................. XV
III. Literature Analysis Results ..........................................................................................XVI
IV. Research Design .......................................................................................................... XVII
V. Conceptual Models Creation and Models Deployment ......................................... XVIII
VI. Experiments and Results Analysis ............................................................................ XXII
VII. Conclusions ..............................................................................................................XXXIII
EXECUTIVE SUMMARY ..................................................................................................... XXXV

I. Contesto Generale .................................................................................................... XXXV
II. Scopo e Struttura della Tesi .................................................................................... XXXV
III. Risultati dell'Analisi della Letteratura ................................................................. XXXVI
IV. Research Design .................................................................................................... XXXVII
V. Creazione dei Modelli Concettuali e loro Implementazione ............................ XXXVIII
VI. Esperimenti ed Analisi dei Risultati .......................................................................... XLII
VII. Conclusioni ....................................................................................................................LIII
1. INTRODUCTION ..................................................................................................................... 1
1.1 Sustainable Development .................................................................................................. 1
1.2 Sustainability in Manufacturing....................................................................................... 4
1.2.1 Management and Control of Energy Consumption ............................................................ 7
1.3 Work Structure and Aim .................................................................................................. 8
2. STATE OF ART OF ENERGY EFFICIENCY PRODUCTION PLANNING AND

CONTROL ....................................................................................................................................... 11
2.1 Introduction ...................................................................................................................... 11
2.2 Literature Review Methodology ..................................................................................... 12
2.3 State of the Art of Energy Aware Production Planning and Control ......................... 15
2.3.1 Production Line.............................................................................................................. 17
2.3.2 Flow Shop ...................................................................................................................... 18
II
2.3.3 Job Shop ......................................................................................................................... 19
2.4 State of Art of IT Enabling ............................................................................................. 28
2.5 Gaps Definition ................................................................................................................ 30
3. RESEARCH FRAMEWORK ................................................................................................ 32

3.1 Introduction ...................................................................................................................... 32
3.2 Research Environment .................................................................................................... 32
3.2.1 Research Questions and Objectives ............................................................................... 34
3.2.2 System Definition ......................................................................................................... 35
3.3 Research Methodology .................................................................................................... 36
3.3.1 Problem Knowledge....................................................................................................... 37
3.3.2 Conceptual Model .......................................................................................................... 37
3.3.3 Coding of the Model and Software ................................................................................ 38
3.3.4 Attainment of a Solution and/or Understanding of the System ..................................... 38
4 MODEL DEVELOPMENT .................................................................................................... 39

4.1 Production Planning ........................................................................................................ 39
4.2 Conceptual Model ............................................................................................................ 41
4.3 System Description........................................................................................................... 41
4.3.1 Input ............................................................................................................................... 44
4.3.2 Buffer ............................................................................................................................. 45
4.3.3 Machines ........................................................................................................................ 45
4.4 Conceptual Model –Base Case ........................................................................................ 48
4.5 The Manzone Nervi 1 Policy ........................................................................................... 55
4.6 The Manzone Nervi 2 Policy ........................................................................................... 67
4.7 Data Collection ................................................................................................................. 81
4.7.1 Model Software Implementation ................................................................................... 84
5. SIMULATION FRAMEWORK ............................................................................................ 91

5.1 Simulation ......................................................................................................................... 91
5.2 Simulation Project ........................................................................................................... 95
5.3 Simulator Choice.............................................................................................................. 99
6. EXPERIMENTS AND RESULTS ANALYSIS .................................................................. 102

6.1 Design of Experiments ................................................................................................... 102
6.2 Routing Phase Effects .................................................................................................... 113
6.3 Inter Arrival Time Variation Effects ........................................................................... 115
III
6.4 Threshold Time Variation Effects ................................................................................ 124
6.4.1 The Manzone Nervi 1 Policy Non-implementation Probability .................................. 127
6.4.2 The Manzone Nervi 2 Policy Non-implementation Probability .................................. 133
7. CONCLUSIONS AND FURTHER DEVELOPMENTS ............................................... 137

7.1 Conclusions ..................................................................................................................... 137
7.2 Further Developments ................................................................................................... 139
Bibliography ................................................................................................................................... 140
ANNEXES ...................................................................................................................................... 145
Annex 1: Experiments ................................................................................................................... 145
Annex 2: Code ................................................................................................................................ 172

A.2.1 BASE CASE ................................................................................................................... 172
A.2.1.1 Source-exit control ................................................................................................... 172
A.2.1.2 Stage A-exit control ................................................................................................. 172
A.2.1.3 Stage B-exit control ................................................................................................. 172
A.2.1.4 Stage C-exit control ................................................................................................. 173
A.2.2 THE MANZONE NERVI 1 POLICY .......................................................................... 173
A.2.2.2 Stage A- routing phase and exit control ................................................................... 173
A.2.2.3 Stage B- routing phase and exit control ................................................................... 177
A.2.2.4 Stage C- routing phase and exit control ................................................................... 181
A.2.3 THE MANZONE NERVI 2 POLICY .......................................................................... 185
A.2.3.2 Stage A- routing phase and exit control ................................................................... 185
A.2.3.3 Stage B- routing phase and exit control ................................................................... 523
A.2.3.4 Stage C- routing phase and exit control ................................................................... 883
A.2.3.5 Method init ............................................................................................................. 1258

IV
List of Figures
Figure 1–1: Rates of energy dependecy of all the EU27 products,2011 [6] ........................................ 3
Figure 1–2: Energy costs for the industrial users [7] ........................................................................... 3
Figure 1–3: Final prices of electricity for industrial users in the main European countries [8] .......... 4
Figure 1–4: Sectors' energy consumption in 2014 [6] ......................................................................... 6
Figure 1–5: Deming cycle [1]   ........................................................................................................... 8
Figure 1–6: Map-road of this work .................................................................................................... 10
Figure 2–1: Map road of literature review methodology ................................................................... 13
Figure 2–2: Reference system for literature classification ................................................................ 15
Figure 3–1: Representation of conceptual model creation. [47] ........................................................ 34
Figure 3–2: Energy states description [48] ........................................................................................ 36
Figure 3–3: Step to follow for a simulation project [1] ..................................................................... 38
Figure 4–1: General architecture for the production scheduling ....................................................... 39
Figure 4–2: Representation of the jobs flow in the system ................................................................ 42
Figure 4–3: Representation of a generic stage ................................................................................... 43
Figure 4–4: Representation of the information flow in the system ................................................... 44
Figure 4–5: Power profile of a production asset [47] ........................................................................ 46
Figure 4–6: Approximated power profile of a production asset [47] ................................................ 47
Figure 4–7: Links between productivity states and energetic states [38] .......................................... 47
Figure 4–8: Representation of the source conceptual model ............................................................. 51
Figure 4–9: Base case conceptual model ........................................................................................... 52
Figure 4–10: Base case conceptual model ......................................................................................... 54
Figure 4–11: The Manzone Nervi 1 policy, routing phase conceptual model ................................... 59
Figure 4–12: The Manzone Nervi 1 policy, conceptual model - choice process of the machine
energy state ................................................................................................................................ 62
Figura 4–13: Conceptual model: communication in the stage........................................................... 65
Figure 4–14: CNJA Policy [2] ........................................................................................................... 68
Figure 4–15: CNJA Policy [2] ........................................................................................................... 68
Figure 4–16: The Manzone Nervi 2 policy conceptual model - routing phase ................................. 70
Figure 4–17: The Manzone Nervi 2 policy conceptual model – choice process of the machine
energy state ................................................................................................................................ 72
V
energy state ................................................................................................................................ 73
energy state ................................................................................................................................ 74
energy state ................................................................................................................................ 75
Figure 4–21: Simulator main screen .................................................................................................. 84
Figure 4–22: Resource statistics chart ............................................................................................... 85
Figure 4–23: Energy statistics chart ................................................................................................... 86
Figure 4–24: Buffer_exit Method example........................................................................................ 87
Figure 4–25: Machine 1 parameters in Tecnomatix Plant Simulation .............................................. 88
Figure 4–26: Machine 1 parameters in Tecnomatix Plant Simulation .............................................. 88
Figure 4–27: Input parameters in Tecnomatix Plant Simulation ....................................................... 89
Figure 4–28: Simulator results screen................................................................................................ 90
Figure 5–1: Hybrid combination of DES and analytic calculation [52] ............................................ 92
Figure 5–2: Simulation of an iterative process [1]............................................................................ 96
Figure 5–3: Process for the conceptual models validity .................................................................... 98
Figure 6–1: Variables making up a model [1] ................................................................................. 103
Figure 6–2: Representation of the Manzone Nervi 1 policy ............................................................ 108
Figure 6–5: Representation of the information flow in the system ................................................. 110
Figure 6–6: Representation of a generic stage ................................................................................. 111
Figure 6–7: Ttime percentage in the different energy states in the base case, the Manzone Nervi 1
policy and the Manzone Nervi 2 policy ................................................................................... 113
Figure 6–8: Routing phase effect: ProcTime=00:00:30-00:01:30-00:02:30; TT=00:01:00 ............ 115
Figure 6–9: IAT variation effects: ProcTime= 00:00:30-00:01:30-00:02:30; TT=00:01:00 .......... 116
Figure 6–10: IAT variations effect: ProcTime= 00:00:30-00:01:30-00:04:30; TT=00:01:30 ........ 117
Figure 6–11: IAT variation effect: ProcTime= 00:00:30-00:01:30-00:04:30; TT=00:01:00 .......... 118
Figure 6–14: IAT effect on system saturation: ProcTime=00:01:30-00:01:30-00:01:30 ................ 123
Figure 6–15: IAT effect on system saturation: ProcTime =00:00:30-00:01:30-00:02:30 ............... 124
Figure 6–16: TT variation effect: ProcTime=00:00:30-00:01:30-00:04:30; IAT=00:02:00 ........... 125
VI
Figure 6–17: TT variation effect: ProcTime=00:01:40-00:02:20-00:03:10; IAT=00:02:00 ........... 126
Figure 6–18: TT variation effect on the Manzone Nervi 1 policy non-implementation probability:
ProcTime=00:01:40-00:02:20-00:03:10; IAT=00:02:00 ......................................................... 132
Figure 6–19: TT variation effect on the Manzone Nervi 1 policy non-implementation probability:
ProcTime=00:00:30-00:01:30-00:04:30; IAT=00:02:00 ......................................................... 133
Figure 6–20: TT variation effect on the Manzone Nervi 2 policy non-implementation
probability:ProcTime=00:00:30-00:01:30-00:04:30; IAT=00:02:00 ...................................... 135
Figure 6–21: TT variation effect on MN 2 non-implementation probability: ProcTime=00:01:40-
00:02:20-00:03:10; IAT=00:02:00 .......................................................................................... 136
VII
List of Tables
Table 1: Models objectives ................................................................................................................ 21
Table 2: Operations table ................................................................................................................... 50
Table 3: Starting and ending time of the jobs in the stage ................................................................. 66
Table 4: Operations table ................................................................................................................... 66
Table 5: Data collection ..................................................................................................................... 83
Table 6: Simulator release list. Update 2013 [47] ........................................................................... 100
Table 7: Simulator release list. Update 2015 [2] ............................................................................. 100
Table 8: Simulator release list. Update 2016 ................................................................................... 101
Table 9: Macchi and Terzi’s variables classification [1] ................................................................. 104
Table 10: Difference of makespan among base case, the Manzone Nervi 1policy and the Manzone
Nervi 2 policy .......................................................................................................................... 107
Table 11: Sequence of visit to the stages ......................................................................................... 111
Table 12: Design of experiments ..................................................................................................... 112
Table 13: Variables value combinations used in figure 6-8 and routing phase effects ................... 114
Table 14: Variables value combinations used in figure 6-9 ............................................................ 116
Table 15: Variables value combinations used in figure 6-10 .......................................................... 117
Table 21 Variables value combinations used in figure 6-16............................................................ 125
Table 24 Variables value combinations used in figure 6-19............................................................ 132
VIII
List of Equations
Equation 1: Energy efficiency formula [9] .......................................................................................... 5
Equation 2: [38] ................................................................................................................................. 24
Equation 3: [38] ................................................................................................................................. 24
Equation 4: [38] ................................................................................................................................. 24
Equation 5: [38] ................................................................................................................................. 24
Equation 6: Example of energy consumption .................................................................................... 46
Equation 7: Saved energy equation [2] .............................................................................................. 56
Equation 8: Threshold time equation [50] ......................................................................................... 56
Equation 9: Threshold time formula adapted by Mouzon et al. [50] ................................................. 56
Equation 10: Calculation of the threshold time [2] ............................................................................ 57
Equation 11: Formula of the threshold time [50] with simulator approximation .............................. 57
Equation 12: Formula of the threshold time [2] with simulator approximation ................................ 57
Equation 13: Final threshold time ...................................................................................................... 57
Equation 14: Consumed energy [2] ................................................................................................... 69
Equation 15: Saved energy [2] ........................................................................................................... 69
Equation 16: Thesis objective .......................................................................................................... 119
Equation 17: Thesis objective .......................................................................................................... 119
Equation 18: Max Saving................................................................................................................. 119
Equation 19: Calculation of the minimum number of jobs in the system in TT in the Manzone Nervi
1 policy..................................................................................................................................... 128
Equation 20: Calculation of the maximum number of jobs in the system in TT in the Manzone
Nervi 2 policy .......................................................................................................................... 128
Equation 21: The Manzone Nervi 1policy non-implementation probability ................................... 129
Equation 22: Calculation of the minimum number of jobs in the system in TT ............................. 129
Equation 23: Calculation of the maximum number of jobs in the system in TT ............................. 130
Equation 24:The Manzone Nervi 1 policy non-implementation probability ................................... 130
Equation 25: Calculation of P0, nmin ............................................................................................. 130
Equation 26: Calculation of k = 1KPk, nmin ................................................................................. 130
Equation 27: Calculation of MN 1 non implementation minimum probability............................... 130
Equation 28: Calculation of P0, nmax ............................................................................................. 130
Equation 29: Calculation of k = 1KPk, nmax ................................................................................. 130
Equation 30: Calculation of MN 1 non implementation maximum probability .............................. 130
IX
Equation 31: Calculation of MN 1 non implementation probability ............................................... 131
2 policy..................................................................................................................................... 133
2 policy..................................................................................................................................... 134
Equation 34: The Manzone Nervi 2 policy non-implementation probability range ........................ 134

X
ABSTRACT

Energy efficiency has become one of the most relevant issues in manufacturing above all as far as
needs for a sustainable development are concerned, actually 42% of domestic energy consumption
is attributable to the Italian industrial sector.
Our thesis wants to be a contribution to the state of art with the development of policies aimed to
energy consumption awareness that allow all the stages in the job shop system to make decisions
about the energy state of the machines inside it, having the possibility of sharing and exchanging
information in real time with the other stages and the system input through a proper ICT
infrastructure.
We have considered a job shop system because it has not been studied deeply from an energy point
of view. Each stage of the system perfectly knows everything concerning its machines and its
buffer, communicating with the other system components it is able to get to know what is
happening in the other stages in every moment and when a job to be worked is arriving, it knows
the waiting times for each job in the various buffers, the processing time and the energy state of all
the machines. The stage is able to look for all the necessary information whenever it actually needs
it and to decide about the energy state of the machines inside it according to the situation in that
moment. Thus the stage can decide to set a machine to standby and to postpone the next job
processing thus saving energy, with an impact on the makespan close to zero.
The proposed energy policies help make decisions in real time according to the situation in that
moment that are not based on statistical data and forecasts.
Our work starts with an analysis of the literature to individuate the gaps and the research questions.
The three fundamental phases are:
- conceptual models definition;
- models development;
- experiments and analysis of the results. This has been possible using a discrete event
simulation software that has allowed us to simulate productive and energy policies,
implementing a personalized algorithm.
These three phases have been iterated and have allowed us to clearly understand the behaviour of
the system we have considered and find solutions to implement the successive cycles.
Thus we have created two energy aware policies validated during the experiments and the results
analysis considering both energy consumption and makespan.
XI
Key words: energy efficiency; energy aware; job shop; flow shop; production line; energy
management; operation scheduling; ICT in manufacturing; discrete event simulation; energy
policies; standby energy; idle energy; energy efficient production.

XII
ABSTRACT

Il tema dell'efficienza energetica è diventato uno dei più rilevanti nel manufacturing soprattutto in
un contesto di esigenza e desiderio di uno sviluppo sostenibile. Il settore industriale in Italia, per
esempio, è attualmente responsabile del 42% del consumo energetico nazionale.
Con questo lavoro vogliamo dare un contributo al settore manifatturiero tramite delle politiche di
efficienza energetica da poter applicare ad un sistema produttivo, in particolare ad un sistema
produttivo con configurazione job shop in quanto in letteratura non è stato studiato
approfonditamente da un punto di vista energetico.
Grazie a queste politiche ogni reparto presente nel sistema prende decisioni riguardo allo stato
energetico delle macchine al suo interno sfruttando la possibilità di condividere e scambiare
informazioni in real time con gli altri componenti del sistema attraverso un'appropriata
infrastruttura ICT.
Ogni reparto del sistema conosce perfettamente tutto ciò che riguarda le macchine, il buffer al suo
interno e comunicando con gli altri componenti del sistema può sapere in ogni momento ciò che sta
accadendo negli altri reparti e quando gli arriverà un pezzo da lavorare, conosce i tempi di attesa di
ogni job nei vari buffer, i tempi di lavorazione e lo stato energetico di tutte le macchine. Il reparto è
in grado di cercare le informazioni che gli servono nel momento in cui ne ha effettivamente bisogno
e di decidere in base alla situazione in quell'istante. Quindi il reparto può decidere di mandare una
macchina in standby e di rimandare la lavorazione del job successivo ottenendo un risparmio
energetico, con un impatto sul makespan prossimo allo zero.
Le politiche energetiche quindi proposte permettono di prendere decisioni in tempo reale sulla base
della situazione in quel momento e non basate su previsioni statistiche effettuate a partire da dati
storici.
Questo lavoro comincia con un'analisi della letteratura per la definizione dei gap e delle domande di
ricerca. Seguono tre fasi fondamentali:
- definizione dei modelli concettuali;
- sviluppo dei modelli;
- esperimenti e analisi dei risultati grazie all’utilizzo di un software di simulazioni a eventi
discreti che permettono di simulare politiche produttive ed energetiche implementando
algoritmi personalizzati.
Queste tre fasi sono state iterate e questo ci ha permesso di capire a fondo il comportamento del
sistema considerato e far emergere progressivamente idee e soluzioni da implementare nei cicli
XIII
successivi. Abbiamo quindi creato due politiche "energicamente consapevoli" testate durante gli
esperimenti e l’analisi dei risultati, considerando sia il consumo energetico che il makespan.
Parole chiave: efficienza energetica; job shop; energy management; ICT nel manufacturing;
simulazione ad eventi discreti; politiche energetiche; standby energy; idle energy; produzione
energicamente efficiente.

XIV
EXECUTIVE SUMMARY

I. General Context
The term “sustainable development” was introduced in the Report “Our Common Future”, drawn
up by the Bruntland Commission in 1987 [1] that defines it as a development able to meet the needs
of the present generations without compromising the ability of future generations to meet their own
needs. Specifically the sustainable development is a model able to include economic, social and
environmental aims.
The companies shall adopt the principle of “sustainability” in their management, simultaneously
considering the financial, social and ecological aspects of their activities. Nowadays companies
shall not only focus on their profit but shall take the economic and social needs of society into
account. In the last few years the idea has been spreading that an activity can be profitable also
when production focuses on the protection of the environment since an eco-friendly company is the
key for a sustainable development.
Energy efficiency is one of the main components of sustainable development meant as an economic
development coherent with the protection of the environment. The most common definition of
energy efficiency in literature is the one given by Patterson in 1996 [7]: “The use of less energy to
produce the same amount of services and useful output”. This quotation can be turned into a
formula:
>?@ABCDE@F @BD>BD
𝐸𝑛𝑒𝑟𝑔𝑦 𝐸𝑓𝑓𝑖𝑐𝑖𝑒𝑛𝑐𝑦 (𝑚𝑎𝑛𝑢𝑓𝑎𝑐𝑡𝑢𝑟𝑖𝑛𝑔 𝑠𝑦𝑠𝑡𝑒𝑚)=
D@DGH IFI?JK EF>BD
Equation 1: Energy efficiency formula [7]
II. Thesis Aim and Structure

Starting from the formula written above, the purpose of our work is to give our contribution to the
manufacturing sector finding some energy efficiency policies that can be applied to a production
system, in particular to a job shop production system. As a matter of fact we are going to show what
the main aspects of a production system are and how it is possible to manage them with the aim of
saving energy. Thanks to our energy policies it is possible to reduce energy consumption and this
can result in a drastic reduction of costs and emissions of harmful substances in the environment.
At the same time we would like to find solutions where the most important performance indicators
XV
of the production world are considered, such as the total completion time of production or the
obtained throughput.
This thesis is composed of 7 chapters: the first one is an introduction of the topic we are dealing
with, the interest in sustainable development as an issue that has been widely discussed in the last
few years and its relevance in the manufacturing sector. The second chapter includes a literature
review about the models that deal with energy efficiency in manufacturing classifying them
according to three fundamental elements and identifying the existing gaps we would like to fill.
Chapter 3 deals with the research questions and our objectives and better describes how we have
decided to carry out our thesis. Chapter 4 contains a detailed explanation of the essence of our
work: the two energy policies hereafter called “The Manzone Nervi 1 policy” and “ The Manzone
Nervi 2 policy” and explains the conceptual model of the base case we refer to and the conceptual
models we have elaborated to explain the logic behind our energy policies. Chapter 5 is about the
simulation framework and the simulator we have used for our experiments. In chapter 6 we explain
our experiments and the results analysis. Chapter 7 includes the conclusions and the future proposed
developments.
III. Literature Analysis Results
We have developed our work after an accurate research on energy efficiency in manufacturing
during which we have found two gaps we have decided to fill. The articles which have been
published in these last years have underlined a growing awareness on energy efficiency in
manufacturing, nevertheless the key performance indicators of the traditional production do not take
completely into account environmental impacts like energy consumption in production planning
and scheduling (Min Dai et al [14]). Despite the development of new methods which support
manufacturing companies in the development of energy-based performance indicators (Gökan May
et al. [15]), more attention is given to the single machine or the single activity rather than to the
whole group of machines that work in a production system. The models we have selected for our
analysis have been classified according to three fundamental elements: solving techniques,
production objectives and production system.
The result of this research highlights that the line is sufficiently studied in terms of energy
consumption and over the years interesting energy policies have been carried out allowing a deeper
study on the matter, the flow shop is theoretically the most studied system but the complexity of the
analysis is simplified by some authors. There are few authors that deal with the job shop system
probably because there are a lot of variables to be considered during the study of a job shop
XVI
configuration. Anyway those who decide to deal with it simplify the problem a lot and despite the
validity of their rules they rely on statistical models without taking into account the technologies
that might allow communication in real time among the several machines. Rapuzzi [2] in her thesis
in 2015 introduces the concept of real time so that the energy aware machines while producing can
communicate with the other machines and make decisions according to the arrival time of the
different jobs to be processed, to the failure of the machines etc.
All the observations we have made are fundamental to understand which direction we shall move in
and thanks to all the researches we have carried out we are able to define the gaps of research where
to start from:
The job shop with the relevant energy policies is not analysed deeply in literature
The existing policies so far do not take into account the ICT infrastructure that allows real
time communication
The purposes we want to pursue are two: first of all we want to increase energy efficiency in a job
shop production system considering energy consumption as the sum of the energy consumed during
the processing time, during the standby and idle state and the time in which the machines go from
idle to standby state and vice versa. At the same time we shall not forget the makespan defined as
the completion time of the entire portfolio. For these purposes we would like to apply energy aware
policies to a job shop configuration using real time technology.
IV. Research Design

After having analysed literature in detail we can formulate the main research questions:
-‐ RQ1
How can the energy efficiency of a job shop production system be improved applying the
Current Job Aware and Current and Next Job Aware energy policies that have been designed
for a line production?
First it is necessary to study the complexity of a job in detail and then adapt the policies to the job
shop itself, considering the system no more as a single flow in a single direction but as a system
with n directions. For this reason it is not possible to talk about “previous” or “following” machine
in general but it will be necessary to refer to the path of a specific job.
XVII
-‐ RQ2
How can ICT technologies be used to efficiently manage a job shop system?
To be able to use ICT technologies it is necessary to manage the real time communication among n
departments understanding what information to obtain, in which moment and how to use it to apply
the energy policies of the first research question.
To be able to fill the gaps in literature and reach the proposed targets we have followed the
methodology proposed by Marco Macchi and Sergio Terzi [11] in the text “Modellazione dei
sistemi produttivi” written in 2009. The authors explain that execution of a simulation project shall
be based on an iterative process whose fundamental steps are:
1. Problem knowledge
2. Conceptual model
3. Coding of the model and software
4. Attainment of a solution and/or understanding of the system
Repeating the process more times it is possible to obtain a better solution reaching a better
knowledge and understanding of the process as well.
V. Conceptual Models Creation and Models Deployment
As shown in literature, before being able to develop a software model and start carrying out
experiments it is necessary to develop the conceptual models that explain the logic of our work. It is
very important to describe and analyse our job shop system first: it is characterized by the input that
introduces the jobs in the system, three stages and the output. Each stage contains a buffer that is
linked to two identical machines that can process the jobs.
Figures 4-2 and 4-3 show the configuration of our system and of a generic stage:

XVIII

Figure 4-2: Representation of the jobs flow in the system

Figure 4-3: Representation of a generic stage
Considering the machines from a production point of view the states can be the following:
• Working: in this state the machine is working a job;

• Idle: the machine is ready but has no job to work;
• Setup: the machine is being prepared to be able to work the next job (for example the
change of a tool);
• Maintenance: the machine is undergoing preventive maintenance or is being repaired after
a failure;
XIX
• Failure: the machine is in failure state. There are different types of failure, some failures
slow the machine down, others stop it;
• Off: the machine is off.
In our work the machines are considered in working or idle state.
Considering the machines from an energy point of view we can identify the following states:
• Working: the machine is working a job and this state requires more power;
• Idle: the machine is ready to work but has no job. The power required for this state is
inferior to the necessary power for the working state.
• Standby: the machine is not ready to work because most of its components are off.
Nevertheless the machine is not off therefore there is energy consumption to supply those
components that are still on;
• Maintenance: the machine is being repaired and requires a certain amount of power;
• Ramp-up: It is the transitional state from standby to idle state. To activate the components
of the machine power is therefore necessary;
• Ramp-down: It is the transitional state from idle to standby state.
The energy consumption we consider in our examples includes working energy, standby energy and
energy consumed during idle times, it is exactly this last energy we aim to minimize during
production. Both our policies are made of two phases:
-‐ routing phase;

-‐ decisional phase on a machine energy state.
The routing phase is the same in both the policies and represents the most innovative aspect of our
thesis. It is a phase in which the stage chooses what machine the job in the buffer is to be assigned
to on the basis of its energy state.
When a job is in the buffer and has to be worked by a machine, the stage analyses the energy state
of the machines in that moment and decides what machine can process the job. The decision is
made on the basis of a priority classification according to which the stage first controls if there are
machines in idle, then in working state with a remaining processing time inferior to the threshold
time and finally machines in standby that can be set to idle state.
XX
The decisional phase on a machine energy state regards the choice the stage makes when a machine
finishes working, thus the stage decides if the machine has to remain in idle ready to work another
job or it has to be set to standby. The considerations the stage makes are different in each policy; in
fact according to the Manzone Nervi 1 policy a machine after working has to be set to standby if it
is not going to receive a job within the threshold time so that it does not remain in idle state saving
energy and consequently saving money.
Figure 6-2: Representation of the Manzone Nervi 1 policy
With the Manzone Nervi 2 policy a machine after working has to be set to standby on the basis of
the two next jobs’ arrival time, thus the machine can be set to standby state even if the first job
arrives within TT (this cannot happen using the first policy) and the second job arrives after a time
calculated as the sum of t* and t**, where t* is the interval between the moment the machine
finishes working and the moment the first job arrives and t** is the interval between the moment
the machine finishes working the first job and the moment the second job arrives.
Figures 6-3 and 6-4 explain how we want to modify the base case to obtain energy savings with the
Manzone Nervi 2 policy.
XXI
VI. Experiments and Results Analysis

XXII
Before carrying out the simulation runs it has been necessary to identify the variables used in the
experiments and thus the design of experiments to explain all the elements to be considered during
the simulation runs and the values to be attributed to each single variable in order to be able to
analyse all the possible situations. According to the experiments we have decided to consider the
value of determined variables fixed and to modify other values to be able to make all the
considerations thoroughly.
Table 9 shows the decision variables, the controllable factors, the non-controllable factors and the
performance variables according to Macchi and Terzi’s classification [1].
Decision Controllable Non controllable Performance

Variables Factors factors variables
Energy saving
X
policy
Processing time X
Set-up times X
Working power
X
Idle power
X
Standby power
X
Off power
X
Ramp-up power
X
Ramp-down power
X
Ramp-up time
X
Ramp-down time
X
Buffers capacity
X
Inter arrival time

X
Threshold time X
XXIII
Transportation
X
times
Energy
consumption X
Total throughput
X
Total makespan
X
Table 9: Macchi and Terzi’s variables classification [11]

We have considered each variable in a different way, some of them have been studied more in
detail and during the simulation runs we have attributed them different numerical values to better
understand the system behaviour. Other variables on the contrary have been considered less
important to verify the energy savings deriving from our policies.
These variables are:
-‐ energy saving: this is the fundamental decision variable of our thesis. The main idea of our
model is to reduce the total energy consumption in a job shop system. Focusing on the
application of specific energy policies during the simulations we have not taken into account
all the components of the total energy but we have only focused on those components that
can be differential and we have compared them case by case. The energy policies refer to
the energy saving obtained from the variation of the energy state of the machines in the
system; in fact they are set to standby or kept in idle state according to the needs. We have
considered the components linked to idle power, standby power, ramp-up and ramp-down
power.
-‐ processing time: we have established deterministic values for the job processing. The
machines are set with the same processing time for every job they have to work. In each
stage the machines are identical but they are different from stage to stage. As for the
processing time of the machines we have established working times for each machine to
create a bottleneck stage that has allowed us to describe and prove the validity of our energy
policies and consequently the energy savings;
-‐ setup times: to simplify the model the setup times have been considered equal to zero;
-‐ ramp-up/ramp-down power and ramp-up/ramp-down times: in our energy policies the stage,
after a machine finishes working, decides whether it has to be set to standby state or not, but
in that moment does not decide when the machine has to be switched on.
When a job arrives in the buffer, the stage has to find the proper machine that can process it
and if necessary the stage will decide to switch the machine from standby to idle state.
XXIV
For this reason if the stage switches the machine from standby to idle state theoretically the
job should wait for a ramp-up time, otherwise to prevent it the stage shall program the
machine switching on from the very beginning. Actually since the job shop system is a very
complex system where there are a lot of directional flows if we program when to switch the
machine from standby to idle state it may happen that the machine switches on at a time t
but that at that time there is no job for it to work because the job has been given to another
machine which has switched on simultaneously.
Considering the sum of ramp-up and ramp-down equal to the threshold time and having the
job to wait for the ramp-up time, for practical reasons we have considered the ramp-down
time equal to the threshold time and ramp-up equal to zero. In this way the makespan does
not increase;
-‐ buffers capacity: since we are in a job shop system if we considered a very limited capacity
of the buffers we would risk the blocking of the system because should all the buffers be full
the machines would not know where to send the jobs after completion. For this reason since
the capacity of the buffers is not essential to our work the buffers in our system have been
oversized;
-‐ transportation: this aspect as well is not essential to our aim therefore we have considered it
equal to 0;
-‐ threshold time (TT): once a machine finishes working the stage decides about its energy
state according to the threshold time. In our work we have hypothesised it equal to the time
necessary to allow the machine to switch from standby to idle state;
-‐ inter arrival time (IAT): inter arrival time of the jobs in the system. The input sends the jobs
to the system at different times according to the various experiments. In the successive
paragraph we indicate the precise values of this variable;
-‐ total throughput: in our work the throughput is fixed and therefore it is a controllable
deterministic variable. We always consider the production of 6 different typologies of jobs
repeated in random sequence composed of 3,000 jobs. Each job is characterized by a
different path inside the system and the random sequence is the same for each run so that it
is possible to compare all the experiments.
As for the output variables we consider energy consumption and total makespan because we want to
verify if after the energy policies and the established input values the energy consumed is inferior to
the base case where the energy policies are not applied.
XXV
We have then defined all the values to attribute to the variables and a design of experiments as
resumed in table 12 below.

Threshold time Inter arrival time Processing time of the machines in the stages
Stage 1 Stage 2 Stage 3
00:00:30 00:00:00 00:01:30 00:01:30 00:01:30
00:01:00 00:00:30 00:00:30 00:01:30 00:02:30
00:01:30 00:01:00 00:00:30 00:01:30 00:04:30
00:02:00 00:01:30 00:01:40 00:02:20 00:03:10
00:03:00 00:02:00
00:04:30 00:02:30
00:05:00 00:03:00
00:06:00 00:03:30
00:08:00 00:04:00
00:10:00 00:04:30
Table 12: Design of experiments

These values have been combined to prove the validity of the Manzone Nervi 1 policy and the
Manzone Nervi 2 policy to study all the aspects of our models and their results.
With the following experiment we want to show how we modify the energy consumption applying
our policies:
XXVI

Figure 6-7: Percentage of times in the different energy states in the base case, in the Manzone Nervi 1 policy and the
Manzone Nervi 2 policy: ProcTime=(00:00:30-0:01:30-00:02:30); IAT= 00:02:00

As figure 6-7 shows, considering one of the experiments we have carried out, in the base case the
machines remain in idle state for a time equal to 50% of the simulation time. Applying the first
energy policy the energy wasted during the idle state is decreased by 90% and applying the second
policy we can obtain a decrease by 95% compared to the base case. Obviously as for the working
energy it is not possible to reduce it since we want to produce the same number of jobs in the same
period of time.
Figure 6-8 shows the first phase of both policies: the routing phase.
XXVII
Figure 6-8: Routing phase effect: ProcTime=(00:00:30-0:01:30-00:02:30); TT= 00:01:00

It is clear that 10% of the savings is due to the routing phase. Increasing the inter arrival time the
effects of the routing phase decrease to zero because the input sends the job in the system more and
more slowly and the stages do not have to decide what machine the job has to go to since there will
be just one machine that works whereas the others will remain in standby state.
Figure 6-9 shows what happens varying the inter arrival time:

Figure 6-9: IAT variation effect: ProcTime=(00:00:30-0:01:30-00:02:30); TT= 00:01:00
XXVIII
In all the experiments when IAT increases the possibility for the stage to set the machine to standby
increases since the jobs go in the system more slowly and therefore the possibility that within TT
there are no jobs to be worked increases. Thus we can say that without changing the other variables
the increase of IAT causes an increase of energy saving compared to the base case.
Figure 6-12: IAT variation effect: ProcTime=(00:00:30-0:01:30-00:04:30); TT= 00:00:30
It is clear that whenever IAT increases the number of times the machines go to standby increases
and obviously with the Manzone Nervi 2 policy it is always higher than the one of the Manzone
Nervi 1 policy, the Manzone Nervi 2 policy allowing a higher energy saving.
XXIX

Figure 6-14: IAT variation effect on the system saturation: ProcTime=(00:01:30-00:01:30-00:01:30); TT=00:01:00

It is clear that the system is less saturated when the inter arrival time increases, actually when IAT
increases the input sends the job to the system more slowly and consequently the machines have to
wait longer between two operations.

Analysing what happens when the threshold time varies but not the processing time of the machines
and the inter arrival time. We expect two contradictory trends:
- percentage decrease of energy saving compared to the base case;

- once the stage switches a machine to standby the possibility for the machine to be set to idle
state is less.

XXX

Figure 6-17: TT variation effect: ProcTime=(00:01:40-00:02:20-00:03:10); IAT=00:02:00

In the example (figure 6-17) it is possible to notice that the first trend is more evident than the
second one, therefore increasing TT the percentage saving compared to the base case decreases.
Two questions arise when noticing this decrease: is there a TT that prevents this policy from
working? If yes, which one?
The answer to the first question in simple, it is yes. The reasoning for the second answer is instead
definitely more complex, it defines the Manzone Nervi 1 policy non-implementation probability
and the Manzone Nervi 2 policy non-implementation probability.
As for the Manzone Nervi 1 policy non-implementation probability we can write:
STU STU
1 − 𝑃N,FOPQ − 𝑃R,FOPQ < 𝑀𝑁1 𝑛𝑜𝑛 𝑖𝑚𝑝𝑙𝑒𝑚𝑒𝑛𝑡𝑎𝑡𝑖𝑜𝑛 𝑝𝑟𝑜𝑏 < 1 − 𝑃N,FO^_ − 𝑃R,FO^_
RVU RVU

Equation 21: The Manzone Nervi 1 policy non-implementation probability range
XXXI

Figure 6-19:TT variation effect on the Manzone Nervi 1 policy non-implementation probability: ProcTime=(00:00:30-
00:01:30-00:04:30); IAT=00:02:00

As for the Manzone Nervi 2 policy non-implementation probability we can write:

STU STU
1 − 𝑃N,FOPQ − 𝑃R,FOPQ < 𝑀𝑁2 𝑛𝑜𝑛– 𝑖𝑚𝑝𝑙𝑒𝑚𝑒𝑛𝑡𝑎𝑡𝑖𝑜𝑛 𝑝𝑟𝑜𝑏 < 1 − 𝑃N,FO^_ − 𝑃R,FO^_
RVU RVU

XXXII

Figure 6-21: TT variation effect on the Manzone Nervi 2 policy non-implementation probability: ProcTime=(00:01:40-
00:02:20-00:03:10); IAT=00:02:00

Considering these two specific examples, the area between the two curves in each figure represents
the non-implementation probability.
VII. Conclusions
This thesis aims to show that it is possible to reduce energy consumption drastically applying some
rules during production and using an ICT infrastructure able to manage information, elaborate it and
create communication in real time among all the components of the system. As a matter of fact our
work wants to represent an evolution comparing the existing models and mainly contributes to two
fields of research:
- the energy-saving policies;
- the information update in real time through ICT infrastructures.
We have decided to give our contribution to the study of the job shop production system because it
is not sufficiently analysed and for that purpose we have started from two existing energy saving
policies regarding the line production and adapted them to a job shop system considering other
innovative aspects as well. The results of our experiments prove that applying the Manzone Nervi 1
XXXIII
policy and the Manzone Nervi 2 policy it is possible to have potential savings up to about 40%
compared to the base case without policies, with an increase of makespan by about 0.01%.
Monitoring energy efficiency in a company is essential not only from an economic but also from an
environmental point of view.
For this reason it is necessary to further develop this issue, in particular focusing on the following
steps:
- increasing the system complexity as follows:
o introducing generic machines with different processing times and powers in the
stages;
o increasing the number of machines in the stage and/or the number of stages in the
system;
- reducing the buffer capacity: in our work we have considered oversized buffers to simplify
the model. For this reason we have not developed Rapuzzi’s third policy [2] that provides
for controls of the available room in the buffers. It might be interesting to understand how to
adapt this policy to a job shop system and what impact it has on the buffer dimension as far
as energy savings are concerned;
- the machines we have used in this work during simulation are not subject to failures, so it
would be interesting to introduce this variable to see how it affects energy savings. Besides
maintenance planning might be contemplated.
In conclusion we think that the results we have reached can extend the traditional control policies in
manufacturing and our work can be a crucial starting point for the definition of more precise
policies to be applied to specific cases.

XXXIV
EXECUTIVE SUMMARY

I. Contesto Generale
Il termine “sviluppo sostenibile” nasce con il Rapporto “Our Common Future” del 1987, presentato
dalla Commissione Bruntland [1], che lo definisce come uno sviluppo in grado di soddisfare i
bisogni delle generazioni attuali senza compromettere la capacità delle generazioni future di
soddisfare i propri bisogni. Specificatamente lo sviluppo sostenibile si trova nell’intersezione tra tre
caratterizzazioni dello sviluppo: sociale, ambientale ed economico.
Le imprese, perseguendo la finalità della creazione del valore, devono orientare la gestione al
criterio della “sostenibilità” considerando contemporaneamente gli aspetti finanziari, sociali ed
ecologici delle loro attività. Oggi un’impresa non può concentrarsi quindi solo sul suo profitto senza
considerare le esigenze economiche e sociali della società. Negli ultimi anni si sta sempre più
diffondendo l’idea che un’attività può essere proficua anche quando la produzione diventa attenta
alla tutela dell’ambiente perché un’impresa eco-efficiente è la chiave per uno sviluppo sostenibile.
La più comune definizione di efficienza energetica in letteratura è quella fornita da Patterson nel
1996 [7]: “L’utilizzo di minor energia per la produzione della stessa quantità di servizi o output
utile”.
Questa definizione può essere tradotta in formula come:
>?@ABCDE@F @BD>BD
D@DGH IFI?JK EF>BD
Equazione 1: Formula efficienza energetica [7]
II. Scopo e Struttura della Tesi

Partendo proprio dalla formula sopra citata (equazione 1), lo scopo della nostra tesi è quello di dare
un contributo al settore manifatturiero trovando delle politiche di efficienza energetica da poter
applicare ad un sistema produttivo, in particolare ad un sistema produttivo con configurazione job
shop. Per conseguire questo obiettivo illustriamo innanzitutto i principali aspetti che compongono
un sistema produttivo e dunque mostriamo come sia possibile gestirli per far sì che si possa
diminuire il consumo energetico. Attraverso l’applicazione delle nostre politiche energetiche è
possibile ridurre il consumo energetico durante la produzione e ciò si può tradurre in un’ingente
riduzione dei costi e delle emissioni di sostanze dannose nell’ambiente.
XXXV
Allo stesso tempo vogliamo proporre una soluzione in cui non vengono persi di vista i più
importanti indicatori di performance che vengono solitamente utilizzati nel mondo del
manufacturing come per esempio il makespan e il throughput.
Questa tesi è strutturata in 7 capitoli: il primo è l’introduzione dell’argomento che stiamo trattando,
un argomento molto discusso negli ultimi anni ossia l’interesse verso lo sviluppo sostenibile e la
rilevanza che assume nel settore manifatturiero. Il secondo capitolo include la ricerca e l’analisi dei
modelli che considerano l’efficienza energetica, li abbiamo classificati secondo tre assi
fondamentali e grazie a questo studio abbiamo identificato due gap esistenti che vogliamo colmare.
Successivamente chiariamo le domande di ricerca, gli obiettivi e come abbiamo deciso di condurre
il nostro progetto. Nel capitolo 4 esponiamo dettagliatamente il fulcro del nostro lavoro: le due
politiche energetiche Manzone Nervi 1 e Manzone Nervi 2 e i modelli concettuali che esprimono la
logica che sta alla base del caso base e delle politiche energetiche che presentiamo.
Successivamente vi è un capitolo dedicato al simulation framework e al simulatore da noi usato
seguito dal capitolo 6 in cui vengono mostrati gli esperimenti effettuati e l’analisi dei risultati. Per
finire vi sono le conclusioni tratte da questo lavoro di tesi e i possibili sviluppi futuri.

III. Risultati dell'Analisi della Letteratura

Siamo arrivate allo sviluppo di questo lavoro a seguito di un’approfondita ricerca legata
all’efficienza energetica nel manufacturing, dalla quale sono emersi due gap che abbiamo voluto
colmare. Dagli articoli pubblicati negli ultimi anni è evidente la crescente consapevolezza di questo
tema, tuttavia gli indicatori di performance tradizionali utilizzati nella produzione non tengono
completamente in considerazione gli impatti ambientali derivanti dal consumo di energia nel
production planning e scheduling (Min Dai et al, [14]). Nonostante lo sviluppo di nuovi metodi che
supportano il mondo del manufacturing nello sviluppo di indicatori di performance energy-based
(Gökan May et al., [15]) l’attenzione è ancora largamente rivolta più alla singola macchina o ad una
singola attività che all’insieme effettivo di macchine che lavorano in un sistema produttivo.
Abbiamo selezionato diversi modelli dalla letteratura e per effettuare un’analisi approfondita li
abbiamo classificati secondo tre assi fondamentali: sistema di produzione, obiettivi di produzione e
tecnica di risoluzione usata.
Il risultato di questa ricerca è che la linea produttiva viene sufficientemente studiata in termini di
consumi energetici e negli anni sono state sviluppate interessanti politiche energetiche che hanno
consentito uno studio più approfondito del tema; per quanto riguarda il flow shop è, a livello
XXXVI
teorico, il sistema produttivo più trattato ma nei casi pratici gli autori riducono notevolmente la
complessità dell’analisi. Ci sono pochi autori che invece trattano il sistema job shop, probabilmente
perché ci sono molte variabili da considerare nel corso dello studio di questo tipo di configurazione;
infatti chi decide di dedicarsi al sistema job shop semplifica molto il problema a livello pratico e,
nonostante la validità delle leggi che vengono da loro elaborate, si basano su modelli statistici senza
tenere in considerazione le tecnologie che consentirebbero la comunicazione in tempo reale tra i
componenti del sistema. Rapuzzi, nella sua tesi del 2015 [2] ha introdotto il concetto di “real time”
per cui le macchine energeticamente consapevoli durante la produzione possono comunicare con le
altre macchine e possono prendere decisioni a seconda del tempo di arrivo dei vari job che devono
essere lavorati, del failure delle macchine ecc.
Queste osservazioni sono state fondamentali per capire in che direzione muoverci e grazie a tutta la
ricerca effettuata possiamo definire i gap di ricerca dai quali siamo partite per il nostro lavoro:
Il job shop con le relative politiche energetiche non viene trattato in maniera approfondita in
letteratura
Le politiche energetiche esistenti non prendono in considerazione l’infrastruttura ICT che

permette la comunicazione in real time
L’obiettivo che vogliamo perseguire è duplice, innanzitutto aumentare l’energy efficiency in un

sistema produttivo job shop considerando il consumo energetico come somma dell’energia
consumata durante la lavorazione, lo stato di standby, nei tempi morti e durante il tempo in cui le
macchine passano dallo stato di idle allo standby e viceversa.
Allo stesso tempo non deve essere perso di vista il makespan definito come il tempo di
completamento di tutti i job da produrre.
A questo scopo vogliamo applicare delle politiche energetiche in un sistema con configurazione job
shop sfruttando le tecnologie real time.

IV. Research Design

Dopo aver analizzato la letteratura in maniera approfondita possiamo definire le principali domande
di ricerca:
XXXVII
1. Come migliorare l’efficienza energetica in un sistema produttivo job shop applicando le
politiche energetiche Current Job Aware and Current and Next Job Aware che sono state
create per una linea produttiva?
È necessario adattare le politiche al job shop, guardando il sistema non più come un unico
flusso con un’unica direzione ma come un sistema con n direzioni. Per questo motivo non si
potrà più parlare di macchina “precedente” o macchina “successiva” in generale ma sarà
necessario riferirsi al percorso di uno specifico job.
2. Come sfruttare le tecnologie ict per gestire efficientemente un sistema job shop?
Per riuscire a sfruttare le tecnologie ict, bisogna essere in grado di gestire la comunicazione
real time, tra n reparti, capendo quali informazioni ottenere, in quale momento e come
utilizzarle per applicare le politiche energetiche della prima domanda di ricerca.
Per poter colmare i gap della letteratura e raggiungere gli obiettivi proposti abbiamo seguito la
metodologia proposta da Marco Macchi e Sergio Terzi nel testo “Modellazione dei sistemi
produttivi” del 2009 [11]. Gli autori spiegano che per condurre un progetto di simulazione ci si deve
basare su un processo iterativo le cui tappe fondamentali sono:
1. La conoscenza del problema
2. Lo sviluppo di un modello concettuale
3. La codifica del modello a calcolatore
4. L’ottenimento di una soluzione e/o la comprensione del sistema
Ripetendo il processo più volte si può passare da una soluzione buona ad una migliore arrivando ad
una migliore conoscenza e consapevolezza del processo
V. Creazione dei Modelli Concettuali e loro Implementazione

Come suggerisce la letteratura, prima di poter sviluppare un modello software e iniziare a fare
esperimenti è necessario sviluppare dei modelli concettuali che esprimono la logica alla base del
nostro lavoro. Risulta quindi molto importante innanzitutto descrivere ed analizzare il sistema job
shop che nel nostro caso è composto da un input dal quale entrano i pezzi nel sistema, un output dal
quale i pezzi finiti escono e da tre reparti all’interno dei quali vi sono un buffer di reparto, che
accoglie i pezzi una volta che questi vengono portati allo stage in cui esso si trova, e due macchine
identiche per ogni reparto. Di seguito la rappresentazione del sistema e successivamente del
generico reparto.
XXXVIII

Figura 4-2: Rappresentazione del flusso dei job nel sistema

Figura 4.3: Rappresentazione di un generico reparto

Considerando le macchine dal punto di vista produttivo, gli stati possono essere questi:
-‐ Working: in questo stato la macchina sta lavorando un job;

-‐ Idle: la macchina è pronta ma non ha un job da lavorare;
-‐ Setup: la macchina sta effettuando delle operazioni necessarie per poter lavorare il job
successivo (come per esempio il cambio di attrezzo);
XXXIX
-‐ Maintenance: la macchina sta subendo delle operazioni di manutenzione preventiva o è in
riparazione in seguito a failure;
-‐ Failure: la macchina è in failure. Ci sono diversi tipi di failure, alcuni rallentano la
macchina altri la fermano;
-‐ Off: la macchina è spenta.
In questo lavoro le macchine vengono considerate o in stato di working o in stato di idle.
Considerando invece le macchine dal punto di vista energetico, possiamo identificare i seguenti
stati:
-‐ Working: la macchina sta lavorando un job e questo stato energetico richiede maggiore
potenza;
-‐ Idle: la macchina è pronta per lavorare ma non ha un job. La macchina accesa assorbe una
potenza inferiore rispetto alla potenza necessaria per lo stato di working.
-‐ Standby: la macchina non è pronta per lavorare perché gran parte delle sue componenti è
spenta. La macchina complessivamente però non è spenta quindi vi è un consumo di potenza
per poter alimentare quei componenti ancora accesi;
-‐ Maintenance: la macchina sta subendo delle operazioni di riparazione e richiede una certa
potenza per effettuare alcune azioni;
-‐ Ramp-up: è lo stato di transizione tra lo stato di standby e lo stato di idle. Per attivare le
componenti della macchina è quindi necessaria potenza;
-‐ Ramp-down: lo stato di transizione tra lo stato di idle e lo stato di standby.
Date queste considerazioni le politiche da noi elaborate sono composte da due fasi:
- fase di routing;
- fase decisionale sullo stato energetico delle macchine.
La fase di routing è uguale in entrambe le politiche e rappresenta l’aspetto più innovativo della
nostra tesi. Nel momento in cui un job arriva nella prima postazione del buffer del reparto dove
deve subire la lavorazione e quindi è prossimo alla lavorazione, il reparto stesso analizza la
situazione energetica in quel preciso istante delle varie macchine presenti al suo interno e decide
quale macchina deve lavorare il job.
Per quanto riguarda la fase decisionale sullo stato energetico delle macchine si parla di decisioni
che vengono prese nel momento in cui una singola macchina termina la lavorazione e quindi il
reparto decide se questa debba rimanere in idle state pronta per lavorare un altro pezzo o se può
passare in standby state. Le considerazioni che il reparto fa a fine lavorazione delle macchine sono
XL
però diverse per ogni politica; infatti con la politica energetica Manzone Nervi 1 le macchine dopo
aver concluso la lavorazione se non ricevono un pezzo entro un tempo di soglia predefinito vengono
mandate in standby.
Figura 6-2: Rappresentazione grafica Manzone Nervi 1
Con la politica Manzone Nervi 2 una macchina dopo la lavorazione viene mandata in standby
considerando l’istante di arrivo dei due pezzi successivi che dovranno subire la lavorazione e
dunque la macchina in esame viene messa in standby anche se il primo pezzo arriva entro TT (cosa
che invece non accade con la prima politica) e il secondo pezzo arriva dopo un tempo calcolato
come la somma di t* e t**, dove t* è l’intervallo tra il momento in cui la macchina termina la
lavorazione e il momento il cui il primo pezzo arriva, t** è dato dall’intervallo tra il momento in cui
la macchina finisce di lavorare il primo pezzo e il momento in cui arriva il secondo pezzo.
XLI
VI. Esperimenti ed Analisi dei Risultati
Prima di effettuare gli esperimenti è stato necessario definire un design of experiments in modo tale
da chiarire quali fossero tutti gli elementi da considerare durante i run di simulazione e quali fossero
i valori da attribuire ad ogni singola variabile per fare in modo che si potessero analizzare al meglio
XLII
tutte le situazioni possibili. Abbiamo dunque deciso, a seconda degli esperimenti, di tenere fissi i
valori di determinate variabili e di modificarne altri in modo tale da effettuare in modo completo
tutte le considerazioni. Con la seguente tabella individuiamo le variabili decisionali, i fattori
controllabili e non e le variabili di performance secondo la classificazione proposta da Macchi e
Terzi [11].
Variabili Fattori Fattori non Variabili di

decisionali controllabili controllabili performance
Politica per il
X
risparmio energetico
Tempi di
X
lavorazione
Tempi di set-up X
Potenza di
lavorazione X
Potenza di idle
X
Potenza di standby
X
Potenza macchine in
off X
Potenza di ramp-up
X
Potenza di ramp-
down X
Tempo di ramp-up
X
Tempo di ramp-
down X
Capacità dei buffer X

Tempo di arrivo dei
job nel sistema X
Tempo di soglia X
Tempi di trasporto X
Consumo energetico
X
XLIII
Throughput totale
X
Makespan totale
X
Tabella 9: Classificazione variabili secondo Macchi e Terzi [11]

Per ogni variabile abbiamo dovuto affrontare delle scelte, alcune variabili sono state maggiormente
studiate e durante i run di simulazione è stato necessario attribuire loro diversi valori numerici per
meglio comprendere il comportamento del sistema. Altre variabili sono state invece ritenute meno
rilevanti allo scopo di verificare il risparmio energetico dato dalle nostre politiche. Analizziamole
una alla volta:

-‐ risparmio energetico: questa è la variabile decisionale fondamentale della nostra tesi. L’idea
alla base del nostro modello è quella di voler ridurre il consumo totale dell’energia in un
sistema job shop. Durante le simulazioni abbiamo applicato specifiche politiche energetiche
e non abbiamo considerato tutte le componenti che formano l’energia totale ma ci siamo
soffermate sui termini che possono essere differenziali, li abbiamo fatti variare e abbiamo
analizzato il risparmio energetico di tutti gli esperimenti. Le politiche energetiche si
riferiscono al risparmio ottenibile dalla variazione dello stato energetico delle macchine del
sistema; infatti queste vengono mandate in stato di standby o lasciate in idle a seconda delle
esigenze. I termini da noi ritenuti fondamentali sono stati quelli legati alla potenza di idle, di
standby, di ramp-up e ramp-down;
-‐ tempi di lavorazione: abbiamo stabilito dei valori deterministici per la lavorazione dei job.
Le macchine hanno lo stesso tempo di lavorazione qualsiasi sia il job che si presenta loro.
All’interno dei reparti le macchine hanno gli stessi tempi di lavorazione, mentre essi
cambiano da reparto a reparto. Le tempistiche sono state prese in modo tale che si crei un
collo di bottiglia e proprio grazie alla presenza di un reparto collo di bottiglia è possibile
descrivere e dimostrare l’applicazione delle politiche energetiche e di conseguenza il
risparmio energetico ottenibile;
-‐ setup times: per semplicità i tempi di setup sono stati presi pari a zero;
-‐ potenza di ramp-up/ramp-down e tempi di ramp-up/ramp-down: nelle nostre politiche
energetiche il reparto stabilisce se mandare in stato di standby le macchine oppure no, ma
non stabilisce a priori l’esatto istante in cui le macchine si dovranno accendere. Nel
momento in cui il pezzo arriverà nel buffer del reparto, il reparto cercherà la macchina più
adatta in quel momento per lavorare e se sarà necessario deciderà se farne passare una da
XLIV
standby a idle. Per questo motivo se procederà nell’accensione di una macchina
teoricamente il pezzo dovrebbe attendere un tempo di ramp-up, in alternativa si potrebbe
programmare a priori l’accensione della macchina in modo tale che non ci sia attesa da parte
del pezzo. In realtà essendo il job shop un sistema complesso in cui i flussi direzionali sono
molteplici, il non decidere a priori quando accendere la macchina ci permette di evitare che
una macchina vanga accesa ad un tempo t ma che nello stesso istante non ci sia un pezzo nel
buffer da lavorare in quanto lo stesso pezzo è stato dato ad un’altra macchina che
contemporaneamente alla prima è stata accesa. Volendo considerare la somma del tempo di
ramp-up e ramp-down pari al tempo di soglia e dato che per essere precisi il pezzo dovrebbe
attendere il tempo di ramp-up, per semplicità abbiamo considerato il tempo di ramp-down
pari al tempo di soglia e il tempo di ramp-up pari a zero. In questo modo il makespan non
aumenta;
-‐ capacità dei buffer: essendo in un sistema job shop se considerassimo un numero limitato di
postazioni nel buffer si rischierebbe il blocking dell’intero sistema in quanto se tutti i buffer
dovessero essere pieni le macchine non saprebbero dove mandare i pezzi una volta terminata
la lavorazione. Dato che per l’oggetto della nostra tesi non è determinante la dimensione del
buffer, li abbiamo sovradimensionati per evitare ogni tipo di problema;
-‐ tempi di trasporto: anche questo termine, come quello appena descritto, non è determinante
per il nostro scopo e quindi è stato stabilito pari a 0;
-‐ tempo di soglia (TT): una volta che una macchina termina la lavorazione, il reparto decide
lo stato energetico della macchina stessa in base ad un tempo di soglia. Nel nostro lavoro
abbiamo ipotizzato che sia pari al tempo necessario per garantire alla macchina di passare
dallo standby all’idle: 𝑇𝑇 = 𝑡?Gc>B> + 𝑡?Gc>A@eF ;
-‐ tempo di arrivo dei job nel sistema (IAT): intervallo di tempo di entrata dei pezzi nel
sistema. L’input inserisce i job nel sistema con intervalli diversi a seconda degli esperimenti.
Nella tabella 12 indicheremo i valori esatti che questa variabile assume;
-‐ throughput totale: nel nostro lavoro il throughput è fisso e quindi si tratta di una variabile
deterministica controllabile in quanto consideriamo sempre la produzione di 6 differenti
tipologie di job ripetuti in una sequenza random composta da 3000 pezzi. Ogni job è
caratterizzato da un percorso diverso all’interno del sistema e la sequenza random è uguale
per ogni run in modo tale che i vari esperimenti possano essere confrontabili.
Per quanto riguarda le variabili in output consideriamo il consumo energetico e il makespan

totale in quanto vogliamo valutare se a seguito delle politiche energetiche e dei valori input
XLV
stabiliti l’energia consumata è minore rispetto al caso base in cui le politiche energetiche non
vengono applicate, vogliamo mantenere la solita quantità di job prodotti nello stesso arco di
tempo.

Con la tabella successiva vogliamo invece mostrare tutti i valori che le variabili hanno assunto
durante i diversi run di simulazione.

Tempo di entrata
Tempo di soglia dei job nel sistema Tempi di lavorazione delle macchine nei reparti
Reparto A Reparto B Reparto C
00:00:30 00:00:00 00:01:30 00:01:30 00:01:30
00:01:00 00:00:30 00:00:30 00:01:30 00:02:30
00:01:30 00:01:00 00:00:30 00:01:30 00:04:30
00:02:00 00:01:30 00:01:40 00:02:20 00:03:10
00:03:00 00:02:00
00:04:30 00:02:30
00:05:00 00:03:00
00:06:00 00:03:30
00:08:00 00:04:00
00:10:00 00:04:30
Tabella 12: Design degli esperimenti

Tutti questi valori sono stati combinati in modo tale da mostrare successivamente dei risultati che
dimostrassero la validità e gli effetti delle politiche energetiche Manzone Nervi 1 e Manzone Nervi
2.
Con il seguente esperimento mostriamo quello che effettivamente vogliamo fare con le politiche
energetiche per quanto riguarda la diminuzione dei consumi:

XLVI

Figura 6-7: Percentuale di tempo trascorsa dalle macchine nei diversi stati energetici nel caso base e con le politiche
Manzone Nervi 1 e Manzone Nervi 2. ProcTime=(00:00:30-0:01:30-00:02:30); IAT= 00:02:00

Come si può vedere dalla figura 6-7, considerando uno degli esperimenti fatti, nel caso base le
macchine passano in idle il 50% del tempo necessario per l’intera produzione. Applicando la prima
politica energetica l’energia sprecata in idle viene abbattuta per il 90% e applicando la seconda
politica energetica si ha un ulteriore abbattimento arrivando al 95% dell’energia in stato di idle in
meno rispetto al caso base. Ovviamente per quanto riguarda l’energia di lavorazione non è possibile
avere un miglioramento dato che vogliamo produrre lo stesso numero di job nel solito arco di
tempo.
Con il seguente esperimento, figura 6-8, mostriamo l’effetto della prima fase di entrambe le
politiche: la fase di routing.
XLVII
Figura 6-8: Effetto della politica di routing: tempi di lavorazione delle macchine nei reparti=(00:00:30-0:01:30-
00:02:30); tempo di soglia=00:01:00

Si può immediatamente notare come il 10% del risparmio ottenuto sia imputabile alla fase di
routing. All’aumentare del tempo di arrivo dei job nel sistema si può anche notare che l’impatto
della fase di routing diminuisce fino ad annullarsi perché l’input inserisce i pezzi nel sistema
sempre più lentamente e il reparto non si trova più nella condizione di decidere su quale macchina il
pezzo deve andare dato che ci sarà una sola macchina a lavorare mentre l’altra rimarrà in standby.
Con il seguente esperimento, figura 6-9, mostriamo cosa succede all’aumentare del tempo di arrivo
dei job nel sistema:
XLVIII

Figura 6-9: Effetto della variazione dell’IAT: tempi di lavorazione delle macchine nei reparti=(00:00:30-0:01:30-
00:02:30); tempo di soglia=00:01:00
Se aumenta l’IAT, aumenta la possibilità che il reparto metta la macchina in stato di standby in
quanto i pezzi entrano più lentamente nel sistema e dunque aumenta la possibilità che entro il tempo
di soglia non ci siano pezzi da lavorare. Possiamo quindi dire che a parità delle altre variabili,
l’aumento dell’IAT comporta un aumento di risparmio energetico rispetto al caso base (figura 6-8).
Come già confermato dall’analisi precedente, all’aumentare dell’IAT aumenta la possibilità che le
macchine stiano in standby dopo la loro lavorazione comportando un aumento del risparmio
energetico ed inoltre all’aumentare dell’IAT aumenta il numero delle volte in cui le macchine
vengono messe in standby, figura 6-11.
XLIX
Figura 6-12: Effetto della variazione dell’IAT: tempi di lavorazione delle macchine nei reparti=(00:00:30-0:01:30-
00:04:30); tempo di soglia=00:00:30
E’ inoltre evidente come all’aumentare dell’IAT il sistema sia meno saturo, come dimostra la figura
6-14; infatti all’aumentare dell’IAT significa che il sistema viene alimentato dall’input più
lentamente e di conseguenza le macchine attendono più tempo tra una lavorazione e la successiva.

Figura 6-14: Effetto della variazione dell’IAT sulla saturazione del sistema: tempi di lavorazione delle macchine dei
reparti=(00:01:30-00:01:30-00:01:30); TT=00:01:00
L

Spostando ora l’analisi sul tempo di soglia vediamo cosa succede al variare di questo valore e
tenendo fissi i valori delle altre variabili. Ci aspettiamo due trend in contraddizione:
- diminuzione percentuale del risparmio energetico rispetto al caso base;
- una volta che una macchina viene spenta dal reparto dopo che questa ha lavorato, la possibilità che
venga riaccesa è minore.

Figura 6-17: Effetto della variazione del tempo di soglia: tempi di lavorazione delle macchine nei reparti=(00:01:40-
00:02:20-00:03:10); IAT=00:02:00

In entrambi gli esempi riportati è possibile notare come il primo trend descritto sia più evidente del
secondo e dunque all’aumentare del TT il risparmio percentuale rispetto al caso base diminuisce.
Dal momento in cui notiamo questa diminuzione sorgono spontanee due domande:
esiste un TT per cui la politica non ha più effetto? Se si, qual è?
Alla prima domanda è più semplice rispondere e la risposta è si, mentre per la seconda il
ragionamento è decisamente più complesso e porta a definire un range di probabilità per cui le
politiche non hanno più effetto.
Per quanto riguarda la politica Manzone Nervi 1 possiamo scrivere:
LI
STU STU
RVU RVU

Equazione 21: Range di probabilità per cui non si attiva Manzone Nervi 1

Figura 6-19: Effetto della variazione del tempo di soglia sulla non implementazione della politica Manzone Nervi 1:
tempi di lavorazione delle macchine nei reparti=(00:00:30-00:01:30-00:04:30); IAT=00:02:00

Figura 6-21: Effetto della variazione del tempo di soglia sulla non implementazione della politica Manzone Nervi 2:
tempi di lavorazione delle macchine nei reparti=(00:01:40-00:02:20-00:03:10); IAT=00:02:00

LII

Considerando questi due specifici esempi, uno per la politica Manzone Nervi 1 e uno per la politica
Manzone Nervi 2, l’area sottesa in ogni grafico tra le due curve rappresenta la probabilità per cui la
politica potrebbe non verificarsi.
VII. Conclusioni

Il nostro lavoro vuole quindi dimostrare che si possono ottenere significative riduzioni sul consumo
energetico implementando alcune modifiche nell'ambito manifatturiero, in particolare
implementando un'infrastruttura ICT in grado di individuare e scambiare in tempo reale le
informazioni necessarie al sistema.
Quindi questa tesi rappresenta un'evoluzione rispetto ai lavori precedenti ed ha principalmente
contribuito a 2 filoni di ricerca:
- il filone dell'energy saving;
- il filone di studio dell'utilizzo delle infrastrutture ICT per un controllo in tempo reale
dell'ambiente produttivo.
Abbiamo deciso di contribuire alla ricerca riguardante il sistema produttivo con configurazione job
shop in quanto non sufficientemente discusso in letteratura e per il nostro lavoro siamo partite da
due politiche energetiche esistenti per la linea produttiva. Abbiamo dunque preso queste due
politiche energetiche e le abbiamo adattate al sistema job shop considerando anche altri aspetti
innovativi.
I risultati dei nostri esperimenti dimostrano effettivamente che applicando le politiche Manzone
Nervi 1 e Manzone Nervi 2 si possono ottenere risparmi energetici importanti, nell'ordine del 40%
rispetto a un caso base senza politiche, con un aumento massimo di makespan dello 0,01 %.
Come abbiamo più volte ripetuto monitorare l'efficienza energetica in un'azienda è molto
importante non solo da un punto di vista economico ma anche da un punto di vista ambientale.
Per questo motivo è necessario approfondire ancora questi filoni di ricerca. In particolare i possibili
approfondimenti di questo lavoro possono essere di diverso tipo:
- aumentare la complessità del sistema. Questo obiettivo si può ottenere tramite diverse
decisioni:
o inserire all'interno dello stesso reparto macchine generiche con tempistiche di
lavorazione diverse e potenze diverse;
LIII
o aumentare il numero di macchine del reparto e/o il numero di reparti nel sistema
- limitare la dimensione dei buffer;
- le macchine che abbiamo usato in questo progetto nel corso delle simulazioni non sono
soggette a failure. Potrebbe essere quindi interessante inserire questa variabile per vedere
come impatta sul risparmio energetico. Inoltre si potrebbe pensare di preparare anche dei
piani per la manutenzione straordinaria dei reparti.
In conclusione riteniamo che il risultato di questo lavoro amplii le politiche di controllo tradizionali
usate nel manufacturing e può essere un ottimo punto di partenza per la definizione di politiche più
precise applicabili a casi specifici.

LIV

1. INTRODUCTION

1.1 Sustainable Development

The term “sustainable development” was introduced in the Report “Our Common Future”, drawn
up by the Bruntland Commission in 1987, [3] a commission created in 1983 whose aim was the
creation of a “global agenda for the change”: “Environment and development are not separated
realities but on the contrary they have a close connection. Actually there is no development if the
environmental resources are deteriorating and the environment cannot be protected if the growth
does not give economic importance to the environmental factor. Shortly they are problems
mutually linked in a complex system of cause and effect which cannot be dealt with separately by
single institutions and with fragmentary policies.”
This statement means that sustainability and development must proceed together:
- sustainability as fundamental condition for the preservation of a lasting development;
- development as a means to overcome poverty, administering the resources to affirm social
equity (within the single communities and in the relationships between them and
individuals) interlocal equity and/or interregional equity (among the various territorial
communities), intergenerational equity (between present and future communities)
simultaneously.
In this report the environment is not considered in itself, but people wealth and the environmental
quality are taken into account, underlining an important ethic principle: the responsibility of the
present generations towards future generations, dealing with at least two aspects of environmental
sustainability: the preservation of the resources and the maintenance of the environmental balance
of the planet [4].
The Bruntland Commission defines the sustainable development as:
- a development able to meet the needs of the present generations without compromising the
ability of future generations to meet their own needs;
- a process in which the exploitation of resources, the direction of investments, the orientation
of technological development and institutional change are in harmony and increase the
present and future potentialities to meet aspirations and human needs.
1
The environment development lies in the intersection of three features of the development itself:
social, environmental and economic [3].
This issue is becoming more and more an important political issue that brings into question the
main development models based on the superiority of human beings compared to nature and
increases the awareness of environmental risk.
This report introduces the concept of energy efficiency underlining the importance of intervention
for the sustainable development in this sector: “A safe energy approach is crucial to a sustainable
development; nevertheless individuating it is not easy.[…] To bring developing countries' energy
consumption up to industrialized country levels the present global energy use should multiply by
five by 2025, but the planetary ecosystem could not stand this, especially if non-renewable fossil
fuels were used.”
Modern appliances shall be redesigned to deliver the same amounts of energy, consuming only
two-thirds or even one-half of the primary energy needed to run traditional equipment. [5]
The issue of energy must play an important role in the technical and engineering sector since it is
becoming more and more crucial for three main reasons:
- the link among energy consumption, climate changes and life styles is a key point for the
construction of a sustainable future. Most of the used energy is obtained from fossil sources
(coal, gas and oil) or from nuclear power stations. These types of energy production have an
unsustainable environmental footprint and are the cause of climate changes. The
International Energy Agency (IEA) provides for recommendation to improve energy
efficiency as a strategy to reduce carbon dioxide emissions because this solution is
potentially more successful and cheaper;
- rapid population growth: in many parts of the world population is increasing at an
unsustainable rate compared to the available environmental sources. The problem does not
concern the number of individuals exclusively but also its correlation to the available
sources;
- security of supply: the European Union imports more than 50% of its energy. Italy is the
fifth country importing energy after the borderline cases of Malta 100%, Luxembourg
97.4%, Cyprus 97% and Ireland 84.4%.
2

Figure 1–1: Rates of energy dependency of all the EU27 products, 2011 [6]
If we consider our country it is immediately clear that energy efficiency is an even more
“important” issue:
-‐ the costs of energy in Italy are on average higher than those in the main European countries
(with particular reference to electricity), clearly affecting the competitiveness of our
country; taking into account the industrial users and the 500-2,000 MWh energy
consumption class, one of the most representative in our market, Italian net prices are 20%
higher than the average in the euro area (21% in 2013) and gross prices 25% higher (26% in
2012) [7].
Figure 1–2: Energy costs for the industrial users [7]
3
Figure 1–3: Final prices of electricity for industrial users in the main European countries [8]
According to the study by RSE (Research on Energy System, company controlled by GSE) about
costs on the market, in Italy prices will increase more and the cost of kWh for the Italian average
user will rise by 2030 due to the increase of fossil fuels and CO2 (affecting the cost of energy) and
the adjustment of the system to the renewable sources.
Over the years more and more accurate rules have been passed to support activities linked to energy
efficiency both at European and international level.
A lot of interventions regarding energy efficiency have been carried out in many sectors: civil,
industrial, transport and agricultural. The Package “20-20-20” and the various Energy Efficiency
Directives (2006/32/CE and 2012/27/UE), only to mention the most known regulations, show that
there has been awareness on energy efficiency at European level for years now, so that the
European Commission has proposed recently to set a new target (non-binding) to reduce energy
consumption by 30% within 2030.
1.2 Sustainability in Manufacturing
The companies shall adopt the principle of “sustainability in their management, simultaneously
considering the financial, social and ecological aspects of their activities. Nowadays companies
shall not only focus on their profit but shall take the economic and social needs of society into
account. In the last few years the idea has been spreading that an activity can be profitable also
when production focuses on the protection of the environment since an eco-friendly company is the
4
key for a sustainable development.
Energy efficiency is one of the main components of sustainable development meant as an economic
development coherent with the protection of the environment. For this reason companies shall
commit themselves to grow in this direction in order to obtain a more liveable environment and a
significant reduction of costs for a more efficient production and to comply with an increasing
number of rules. In literature there are different definitions of energy efficiency. The most common
is the one given by Patterson in 1996 [9]: “The use of less energy to produce the same amount of
services and useful output”.
Therefore less energy consumption to meet determined requirements means better energy efficiency
of the system being analysed.
Energy efficiency can be turned into a formula:
>?@ABCDE@F @BD>BD
D@DGH IFI?JK EF>BD
Equation 1: Energy efficiency formula [9]
It is expressed by a percentage; 0% corresponds to the total “waste” of a system, whereas 100%

corresponds to a situation where the energy output is transformed in a result. The cases being
described are utterly theoretical since any process meets at least some needs and no process is able
to have no wastes. It is possible to talk about energy efficiency referring to very different systems:
from the performances of an engine to those of an industrial department or of a whole country. If all
the data are known there are mathematical formulas that allow to scientifically calculate the degree
of energy efficiency, for example of an engine. As the system becomes larger and more complex, it
is necessary to resort to indicators and statistics that allow to evaluate the level of energy of the
analysed system with a good approximation.
Anyway generally speaking energy efficiency is meant to be the capability of using energy in the
best way. It shows all the actions of planning, scheduling, designing and creation that allow to
consume less energy obtaining the same results.
When energy efficiency is referred to an energy system as a whole it indicates the ability to
guarantee a determined production process or service supply using the least quantity of energy.
Energy consumption is a variable cost that has a strong impact on a lot of companies and is
therefore one of the factors giving significant opportunities to reduce costs. Focusing on energy
efficiency it is possible not only to reduce costs and carbon dioxide emissions, but also to reduce
the risk for a company to have “unstable” energy costs and not to be able to comply with the several
5
regulations on environmental sustainability. For these reasons companies must focus more on
energy consumption and this is obviously more important if it is high. In Italy one of the most
energy-consuming sector is the industrial one [10].
Figure 1–4: Sectors' energy consumption in 2014 [6]
Energy saving is an important criterion of evaluation to test the efficiency of a lot of manufacturing
companies and can contribute to cost reductions, but the energy efficiency interventions are
strongly underestimated. There are several barriers hindering the implementation of energy
efficiency and this issue is being dealt with by several authors. According to Conor Walsh and
Patricia Thornley [11] there are four main barriers:
-‐ structural barriers: when a new structure is being developed it may have different
characteristics and needs from the ones previously developed and therefore various
restrictions might be found. The structural barriers can be physical such as infrastructures or
less tangible as well;
-‐ market barriers: the market is not inclined enough to acquire determined technological
resources;
-‐ interaction barriers: the development of know-how, skills and products that are not strictly
linked to the target;
-‐ performance barriers: these are areas where technology fails to meet the end user’s
requirement somehow. These are likely to be particularly important in energy efficiency
measures in the process industries where efficiency measures will normally be integrated
into the overall process scheme and so there is the possibility to impact on the existing
process performance.
The first two barriers can be considered external and the last two internal.
It is thus important to place energy efficiency among companies’ priorities to indicate what the
critical areas of intervention are and the best practices to adopt that can help reduce wastes and thus
6
get an economic and environmental advantage both for companies and society.
In a manufacturing company four major areas for research and action regarding energy-efficient
manufacturing are discussed [12]:
-‐ new energy sources for factories;
-‐ more efficient production processes;
-‐ energy utilisation in collaborative frameworks;
-‐ management and control of energy consumption.
Our work is relative to the last area.
1.2.1 Management and Control of Energy Consumption

Management and control of energy consumption is fundamental to know how energy is used and
why, thus representing the starting point for any further improvement measure. One of the most
important research topic deals with energy-aware production planning and control: effective energy
control systems have to be developed, using the information of sensors and in process measurement
together with advanced systems for energy efficiency measurement.
The issue is widely dealt with in the first chapter of the second volume of the text “Modellazione
dei Sistemi Produttivi” by Marco Macchi and Sergio Terzi [1], who write: “Actually it is not
possible to improve a system or a production process adequately if accurate performance measures
are not available”. With this sentence the authors want to underline that it is not possible to improve
a production system without knowing it thoroughly, without feedback data of the system as a
starting point for the data storage of the performances to be improved.
The methodological reference proposed by Macchi and Terzi to individuate the activities linked to
the performance improvement is the W.E. Deming Cycle [1] that is a model studied for the
continuous improvement of performance in a long term perspective: “It is useful to promote a
culture of quality aimed to the continuous improvement of the processes and the optimization of
resources. It starts from the assumption that in order to obtain the best quality the constant
interaction among research, design, checking, production and sales is necessary”. This method
consists in the repetition of four activities: Plan, Do, Check and Act.
- Plan: in this phase it is necessary to analyse the current situation, identify the critical
performances, diagnose the causes of inefficiency and plan the interventions to carry out;
 
7
- Do: phase in which the decided interventions are carried out;  
- Check: measurement of critical performances after the carried out interventions;  
- Act: phase in which modifications, if any, are implemented and actions to make them
permanent are consolidated. The importance of data monitoring and controlling activity
is to be underlined since it allows to carry out the Check phase of performances in order
to be able to improve them if necessary.
Figure 1–5: Deming cycle [1]  
1.3 Work Structure and Aim
This work falls within the context of the above mentioned interventions on the system
performances. It analyses a job shop system taking into account energy consumption as main
performance with the aim of decreasing it to increase energy efficiency, considering the trade-off
between energy saving and makespan as well. To reach this target energy policies are applied to
industrial machines which have been studied for the first time by Rapuzzi Nicole [2] in her thesis
and which we have decided to apply to a job shop production system with the necessary
modifications.
This thesis is divided into seven chapters. After this first introduction, there is a chapter about the
8
state of art where the literature on energy efficiency is analysed trying to mainly focus on the
models which have been used so far to reduce energy consumption and on the existing energy
policies. The third chapter shows the gaps individuated in literature and the research questions on
which our work is based. The following chapter deals with simulation, its characteristics and
contains a review of the DES software used. The fifth chapter shows the conceptual models that
explain the logic of the carried out energy policies and the implemented modifications in detail.
The last two chapters contain the explanation of the carried out experiments, the analysis of the
results and the conclusion of the work including some proposals for future developments of the
thesis.
9

Figure 1–6: Road-map of this work
10
2. STATE OF ART OF ENERGY
EFFICIENCY PRODUCTION
PLANNING AND CONTROL

2.1 Introduction
As widely discussed in the previous chapter, the manufacturing sector is the main responsible for
energy consumption and CO2 emissions so far with 42% of electric power consumption [6];
actually in the last few years sustainability in the industrial field has been taken more and more into
consideration since a consumption reduction in this sector would sensibly contribute to improve the
environmental and economic conditions.
Besides the companies tend to carry out sustainability projects and to deal with energy efficiency on
the one hand to comply with the new rules and regulations on the matter and on the other hand to
try to reduce the high energy costs.
Therefore in our thesis we want to develop the current topic of sustainability and at the same time to
contribute to the research in the industrial field which has particularly attracted us in all these years.
In particular, as we will better explain below, we want to focus on the management and control of a
job shop production process composed of three intelligent stages able to communicate with each
other in real time. Within each stage of the system there is a real time control able to manage the
energy state of the machines according to their characteristics and their working time. In this way it
is possible to switch the machines from idle to standby state and vice versa every time it is
convenient to save energy. The system is thus able to calculate traditional indicators such as
makespan and throughput as well as indicators linked to the energy states.
We have developed our work after an accurate research on energy efficiency in manufacturing
during which we have found two gaps we have decided to fill. The articles which have been
published in these last years have underlined a growing awareness on energy efficiency in
manufacturing, nevertheless the key performance indicators of the traditional production do not
11
completely take into account environmental impacts like energy consumption in production
planning and scheduling (Min Dai et al. [13]).
Despite the development of new methods which support manufacturing companies in the
development of energy-based performance indicators (Gökan May et al. [14]), more attention is
given to the single machine or the single activity rather than to the whole group of machines that
work in a production system. In this regard for example Fadi Shrouf et al. [15], have proposed a
mathematical model to minimize energy consumption costs for single machine production
scheduling during production processes, and besides Hae-Sung Yoon et al. [16] suggest a novel
hierarchy of energy saving technologies for machine tools, from the perspective of a single device
manager, technologies for control and cutting improvement, such as novel lubrication and assisted
machining systems, were introduced, and their effects were presented. Gülsüm Mert et al. [17] in
their article published in 2015 have shown how services not only increase the user benefit but also
offer a possibility to improve Key Performance Indicators regarding energy efficiency.
From the above mentioned articles it appears that the authors have given different solutions to reach
a higher level of energy efficiency but have taken the single aspects into account and not the system
as a whole. For this reason we want our work to be focused on scheduling in a production system
considering not only one machine but all the machines existing in the system, configuring the
production system with three intelligent stages able to communicate all their activities in real time,
simultaneously monitoring different types of indicators, both those relative to the working time and
throughput and those linked to energy consumption.
2.2 Literature Review Methodology
Literature research and consequently the literature review are relative to the issue of energy
efficiency in manufacturing starting from a general analysis to reach a specific one relative to
production planning and control, modelling and simulation of a production system with job shop
configuration. It is thus possible to represent our work of literature review through the conceptual
model below.
12

Figure 2–1: Road-map of literature review methodology
This phase has been extremely important for us since it has been possible to get deep into the topic
and understand the real problems that might be found in manufacturing in particular as far as energy
is concerned. We have examined the themes that have been dealt with worldwide so far being able
13
to define the gaps in literature and the specific topic we have decided to focus on. As it is possible
to see in the conceptual model, first of all it has been necessary to define the target of our research.
At the beginning our goal was to collect general information about energy efficiency in
manufacturing in order to clearly understand what the main problems arising in this sector were.
Later the aim of our research totally focused on production planning and control, modelling and
simulation.
We have selected the articles to be studied including some key words in our research such as energy
efficiency, energy aware, job shop, flow shop, production line, energy management, operation
scheduling, ICT in manufacturing, discrete event simulation, energy policies, standby energy, idle
energy, energy efficient production.
We have obtained consultation materials from the library of the Politecnico of Milan and from
constantly up-to-date portals like Science Direct, Scopus, Engineering Village and Google Scholar.
The articles have been firstly selected through the key words contained in the abstracts and then
through a careful reading and analysis of their content.
Besides we have deepened our analysis using different strategies of research for example starting
from a text we considered important for our research we have analysed the texts that were cited in it
or we have looked for other texts where it was cited.
In the last decade a lot of articles dealing with social, environmental and economic sustainability
have been written and their number is growing compared to the previous years. Obviously we have
made another selection reading several abstracts and we have chosen the models to be analysed
according to the specific nature of the topic, how energy efficiency is considered and the
importance attributed by the authors, the importance of the journal on which the article was
published (we have chosen Q1 ranking articles mainly according to the ranking proposed by
Scientific Journal Rankings [18] ) and the year of publication.
In this way we have obtained several models which are described in detail in paragraph 2.3
We have consulted texts, theses written by other students of Politecnico of Milan, slides and
materials supplied during the classes we attended at Politecnico to study and verify these topics.
14
2.3 State of the Art of Energy Aware Production Planning and Control
As we have written in the previous paragraph we have carried out a deep analysis on energy
efficiency in manufacturing and in particular way in the production planning. We have selected
some articles dealing with this topic and we have analysed them carefully to understand how the
authors consider energy efficiency in their models and how we could develop our study. To better
explain the research we have done, before the implementation of our work it has been necessary to
classify the models we have taken into account using three axes.
The models we have selected for our analysis, as shown in the graphic, have been classified
according to three fundamental elements: solving techniques, production objectives and production
system.

Figure 2–2: Reference system for literature classification
Solving Techniques
Optimization problems are concerned with finding the values for one or several decision variables
that meet the objectives without violating the constraints [19]. Since the linear ordering problem is
NP-hard, we cannot expect to be able to solve practical problem instances of arbitrary size to
optimality. We often have to be satisfied with computing approximate solutions [20]. The methods
used in these cases are called heuristic algorithms or simply heuristics. So we can talk about genetic
algorithms that are adaptive heuristic search algorithms premised on the evolutionary ideas of
natural selection and genetic. The basic concept of Genetic Algorithms is designed to simulate
processes in the natural system necessary for evolution, specifically those that follow the principles
of survival of the fittest first laid down by Charles Darwin.
Another way to analyse a problem is simulation. As a matter of fact with simulation it is possible to
15
reproduce a real situation and to immediately evaluate the results.
We have verified that the problems examined in the articles are mainly solved using heuristic
models since the large number of variables and parameters to be considered and the complexity of
the themes and the objectives that are generally more than one do not allow to reach a single best
solution but a solution which is considered good and acceptable. As a matter of fact these problems
are generally NP-hard so it is not possible to find a solution using traditional methods and the time
needed to find a solution increases exponentially when the dimension of the problem increases.
Different methodologies have been proposed to solve this type of problems and in 1975 Holland
presented the genetic algorithm according to the evolutional and genetic mechanics in nature. The
genetic algorithm has been an efficient approach to solve combinatorial optimization problems [21].
Genetic algorithms are adaptive methods which may be used to solve optimization problems and
are based on the genetic process of biological organisms. Over many generations, natural
populations evolve according to the principle of natural selection, i.e., survival of the fittest. At each
generation every new individual (chromosome) corresponds to a solution (Salido et al. [22]).
It is exactly with the genetic algorithm that most of the authors we have considered have solved the
problems they presented. For example focusing on single-machine scheduling, Yildirim and
Mouzon (2011) propose a mathematical model to reduce total completion time and minimize the
energy consumption of a single machine; they have used a multi-objective genetic algorithm to
generate an approximate set of non-dominated solutions without considering energy consumption
costs during on-peak or off-peak hours which have been considered in the paper of Fadi Shrouf et
al. [15]. As a matter of fact they propose a mathematical model to minimize energy consumption
costs for single machine production scheduling during production processes utilizing a genetic
algorithm technology to obtain a ‘near’ optimal solution.
Focusing on the total production system and not on the single machine Xiang Liu et al. [23] in 2008
use the genetic algorithm to deal with the hybrid flow shop scheduling problem; Min Dai et al. [13]
combine the genetic algorithm (GA) based on a matrix encoding scheme with the simulated-
annealing algorithm (SA) based on the mechanism of hormone regulation to solve the mathematical
model. Yi et al. [24] propose an emission-aware multi-machine job shop-scheduling model for
minimizing both carbon emissions and makespan; they use a multi-objective genetic algorithm to
solve the optimization problem.
Yamin Wang and Xiaoping Li [25] consider the bi-criteria no-idle permutation flow shop
scheduling problem with makespan and mean tardiness minimization and they solve it with the
16
shuffled frog leaping algorithm that is inspired by the behaviour of a group of frogs seeking food in
a swamp. Shuffled Frog Leaping Algorithm (SFLA) is a meta-heuristic algorithm which was first
proposed by Eusuff and shows high performance with a few parameters.
Production System and Production Objectives
Our research is focused on models of Production Planning & Control and Scheduling in energy
efficiency in manufacturing. We have seen that the various authors consider energy consumption in
different ways at different levels; in fact some authors consider it as a primary objective and others
as a constraint to an optimization problem where the primary objective is different. Analysing the
objectives in detail we have found: makespan minimization, tardiness minimization, total energy
consumption minimization, peak power minimization, carbon emissions minimization, energy costs
minimization and production costs minimization. Summarizing we have time, energy, power and
costs objectives that according to the analysed problems are expressed in objective functions that
are either mono-objective or in most cases multi-objective, increasing the complexity of the
analysis considerably. The objectives that are considered vary according to the production system
taken into account. An analysis considering first the production line, the flow shop and then the job
shop is shown below.
2.3.1 Production Line
A production line is a system architecture of production composed of a sequence of m machines

where all the products follow the same working cycle visiting the stages composing the line in
sequence.
As for the production line among the analysed models we have observed both mono-objective
problems underlining the energy consumption and multi-objective problems. An example of mono-
objective problem is given by A. Cataldo et al. [26] who consider the problem of optimizing the
production scheduling of a multiple-line production plant composed of parallel equivalent machines
which can operate at different speeds corresponding to different energy demands. They define the
cost function to be minimized that includes the production, energy consumption and movements of
the jobs. Lin Li and Zeyi Sun [27] minimize the energy consumption cost under the constraint of
system throughput invariant which is described by the length of available time period for energy
state adjustment during which the system throughput is not influenced. Alain Haıt and Christian
17
Artigues [25] have written a paper with the goal of minimizing the scheduling costs, depending on
the energy consumed and on penalties when the power exceeds a given subscribed value.
Considering now the multi-objective models we have found a paper written by Guorong Chen et al.
[28] where a Bernoulli line is considered (a synchronous line with all machines having identical
cycle time) and the trade-off between productivity and energy-efficiency in production systems is
discussed and the energy-efficient production problem is formulated as a constrained optimization
problem. T. Stock, G. Seliger [29] minimize the total energy consumption of all machine tools and
the total power consumption of all machines at one time period.
In conclusion the line is sufficiently studied in terms of energy consumption and over the years
interesting energy policies have been carried out that allow a deeper study on the matter.
For this configuration we have models where energy efficiency is defined both explicitly, therefore
in the objective functions and within the constraints and implicitly, where the proposed problem is
solved with solutions of remanufacturing of the process planning. Urban et al. [30] propose a
problem of balancing of unpaced synchronous production lines that can result in smaller facilities
and reduced idle time (hence, reduced energy usage).
2.3.2 Flow Shop
The flow shop is a system configuration represented as a set of stages where more machines with
the same technological characteristics are present. All the parts to be processed are defined by the
same sequence of visit to the stages.
An example of mono-objective models relative to the flow shop is the one given by Wang et al. [31]
that consider a problem involving the scheduling of a set of jobs on parallel machines with different
machining conditions for each job. The system objective is to minimize the makespan given a
maximum threshold for power consumption during machining. Fang et al. [32] instead deal with a
multi-objective problem that simultaneously considers the peak power load, energy consumption,
and associated carbon footprint in addition to cycle time.
Lin et al. [31] minimize both makespan and carbon footprint; in terms of machining process, carbon
footprint is caused by raw materials, energy (mainly electricity), and additional consumptions, such
as cutting tools, cutting fluid, and lubricant. In terms of a flow shop scheduling problem, carbon
18
footprint is also generated by other activities, including the loading/unloading of jobs, machines'
waiting for the processing of the next job and so on. They want to minimize these emissions
without omitting the makespan.
Liu et al. [33] have written a paper that considers the energy consumption minimization in a flow
shop scheduling problem. The objective considered here is to minimize the total wasted energy
consumption which is a weighted summation of the idle time of each machine.
So we have seen some examples where the energy used is expressed in the objective function both
directly and in terms of carbon emissions and peak power consumption. It is possible to find a
sustainable approach also in models where only the factors of time are minimized but where the
importance of reducing consumptions is underlined within constraints.
In this context, Bruzzone et al. [34] have written an article where the approach, based on a MIP
model, modifies the original timetable in order to reduce the shop floor power’s peak while
accepting possible worsening of the scheduling objectives, tardiness and makespan.
In conclusion the flow shop is the most studied system but the complexity of the analysis is reduced
by the authors since in the examples they show a simplified situation compared to the theory they
propose, the machines that are considered are always identical in terms of working time and energy
consumption, the number of machines and jobs is always reduced. For example K. Fang et al. [32]
show an interesting study on a multi-objective mixed integer programming formulation for flow
shop scheduling where they simultaneously minimize the peak total power consumption, the carbon
footprint and the makespan, and during the analysis they study a situation with two machines and
three jobs to be processed.
2.3.3 Job Shop
A job shop represents a configuration with more stages, each stage having more machines with the
same technological characteristics. In this system there are different jobs to be processed and each
job is described by a different working cycle.
We have studied different authors that deal with energy efficiency in manufacturing considering
this production configuration and we can say that this topic has been playing a more important role
19
in the last few years and has been considered at the same level of other industrial aspects such as
working time, makespan and production costs.
As for the job shop all the models being analysed are defined with an objective function which
considers more aspects simultaneously. For example Yi et al. [24] in their paper propose an
emission-aware multi-machine job shop scheduling model with the objectives of minimizing carbon
emissions and makespan; Yan He et al. in 2005 [35] and in 2014 [36] consider the job-shop
scheduling problem in machining systems, they propose dual objectives to be minimized: energy
consumption and the makespan. Both texts present some differences in terms of energy calculation
that is expressed with different components we will analyse later. We think that the model they
presented in 2014 is very important for our thesis since it is one of the most exhaustive in terms of
energy factors. Another model where makespan and the total consumed energy are minimized has
been written by May et al. [37], who consider all the energy states of the machines (off, standby,
idle, setup and working) and in order to assess the benefits of managing the different energy states
of machines to reduce electricity consumption of the productive system, they introduce different
machine behaviour policies that are then applied using a genetic algorithm.
Salido et al. [22] as well consider the completion time of all the tasks and the energy used as
objective but their article is the only one we have analysed that takes the generic machines in a job
shop system into account.
Also Lang et al. [38] to solve a multi-objective flexible job shop scheduling problem, which
considers dual-resource constraints of machines and workers and uncertain operation time
constraint, in the objective function consider not only the delivery satisfaction and process cost
(where the process cost consists of labour costs, power costs and dynamic fuel costs), but also
energy consumption and noise pollution.
Jiang et al. [39] build a multi-objective Flexible Job-shop Scheduling Problem (FJSP) optimization
model in which the optimization objective of scheduling model can be written as: min(T, C, Q, E).
T represents the total processing time, C is cost, Q is quality and E is energy consumption. The
processing cost includes the cost of materials and production.
These last two analysed models are very interesting as far as the calculation of the components is
concerned, but if they are all considered in the objective function we may lose sight of our primary
objective that is energy efficiency.
20
Other authors such as Zhang et al. [40] do not express energy efficiency directly but with the
redesigning of the process planning they achieve the sustainability goals; actually process planning
and scheduling play important roles in the organization of remanufacturing activities and directly
affect the overall performance of a remanufacturing system. They theoretically deal with an
interesting bi-objective problem where there are two different machines and different jobs to be
processed, they minimize the makespan and a performance score that depends on the path the jobs
have followed. The jobs can visit the first machine M1 and then the machine M2 indifferently, the
difference lies in the different working times according to the chosen path. They take a bi-objective
stochastic problem into account since they do not know the exact number of jobs in each category
during the process planning, they later report a numeric application of the problem that becomes
mono-objective and deterministic since the performance score is calculated and therefore the
number of jobs and their paths are defined as well. This is done due to the high calculation
complexity that a multi-objective problem implies, but by reducing the situation considerably, there
is a risk of making strong hypotheses and not considering all the problems implied in a system.
The summary table below underlines all the objectives reported by the authors in the various
models.
Min energy Min Min carbon Min Max

consumption makespan footprint production quality
cost
[35] x x
[38] x x x x
[24] x x
[22] x x
[36] x x
[39] x x x x
[40] x
[37] x x
Table 1: Models objectives
In conclusion the issue of energy efficiency is playing a more and more important role in the
definition of the problems of process planning control and scheduling; actually we have found the
total energy consumption as a primary objective both in mono-objective models and multi-objective
ones, which underlines a sustainable approach in manufacturing as well. In the models where
energy consumption is not directly expressed in the objective function, it can be found in the
21
constraints otherwise proxies such as the minimization of peak power consumption or minimization
of energy costs are used.
Considering the energy consumption calculation in the various models in detail the components
being taken into account differ from each other according to the author, that is some authors only
consider the energy used for the jobs processing, others consider the energy consumed during idle
time or standby as well, others also consider the energy consumed for the job setup, as well as the
machine setup, switching on and off.
It is also possible to observe a historical evolution of the total energy taken into account. He Yan et
al. [35] in their article written in 2005 have defined a model where in the objective function there
are the energy consumption of the machining system and the makespan. The total energy is only
related with the machining time as a matter of fact they just multiply the power necessary to process
each job by the time necessary to process them.
In 2007 Gilles Mouzon, Mehmet B. Yildirim & Janet Twomey [41] considered the same model but
beside the working energy calculated as power to process a job per unit time, they also considered
the idle energy, expressed as idle power for the time in idle mode and the turn on/turn off energy
(setup energy). They consider the energy used for the machine switch-on and switch-off because it
is observed that there can be a significant amount of energy savings when non-bottleneck (i.e.
underutilized) machines/equipment are turned off when they are in idle for a certain amount of
time.
He Yan et al. [41] in 2014 reformulated the same model defining energy as the sum of the energy
consumed for the processing, the energy consumed by machine tools when they are not machining
and the setup energy that is evaluated by multiplying the idle power by the time for tool and
workpiece setup. Nevertheless they do not consider the energy policies such as those proposed by
Mouzon et al. [41] to reduce the idle times.
Mouzon in 2007 [41] started a new line of research relative to the development of energy policies
based on the switching on and off of machines to make it possible to save energy during idle states
as far as the production line is concerned.
Frigerio and Matta in their papers written in 2014 [42] and 2015 [43] consider the following states:
out-of-service, on-service, warm-up and working. In the out-of-service state (standby state) some of
22
the machines modules are not ready, indeed, only the emergency services of the machine are active
while all the others are deactivated.
May et al. in 2015 [37] have elaborated four energy policies that contemplate the switching on and
off of the machines, and only in the forth one did they consider the possibility of putting them in
standby mode.
Despite the validity of their rules they rely on statistical models without taking into account the
technologies that might allow communication among the several machines in real time. Rapuzzi [2]
in her thesis in 2015 introduces the concept of real time so that the energy aware machines while
producing can communicate with the other machines and make decisions based on the arrival time
of the different jobs to be processed, the failures of the machines etc. Both Frigerio and Matta [42]
as well as Rapuzzi consider the line as a production configuration, thus our aim is to adapt their
rules and in particular Rapuzzi's policies to a job shop configuration. It has been necessary to
consider the system no more as a single flow with only one possible direction by as a system with n
possible directions. Besides the models and rules established by these authors as well as most of
the authors studied during our analysis consider identical machines and do not contemplate the
possibility of having to face a situation in which the machines are generic and therefore
characterized by different working times or different necessary processing power.
We also focused on May et al. [37] policies because they have studied the job shop configuration.
As a matter of fact May et al. in the article “Multi-objective genetic algorithm for energy-efficient
job shop scheduling” consider a system with job shop configuration and elaborate four energy
policies with the purpose of increasing energy efficiency. Besides they formulate a problem with
the aim of minimizing the makespan and the total energy consumption and solve it using a genetic
algorithm.
1. First policy: since they are working with batch of jobs, they consider all the machines
switched on when the first operation is started and switched off when the last operation is
over.
2. Second policy: it is similar to the first one with the only difference that the machines are
individually switched on when required to process their first operation and switched off
upon conclusion of the last operation.
23
3. Third policy: the machines are still individually switched on at their first operation and off at
their last but in addition there is the possibility to switch them on and off when they are idle
in the middle of the production batch. When the TEC of switching the machine off and on
again for a certain time period t is less than the energy consumption during the idle state, it
is favourable to apply this policy:
Equation 2: [37]
4. Fourth policy: the standby state is added. Depending on the least energy consumed, it is
possible to decide to switch the machine on and off again or switch the machine to standby
or leave the machine in idle state. The inequalities below describe when a certain behaviour
is to be chosen, based on energy consumption.
The machines should be switched off and then on if:
Equation 3: [37]
The machines should be put in standby mode if: 
Equation 4: [37]
The machines instead should be kept idle if:
Equation 5: [37]
24
where Pidle, power required to remain in idle state [kW]; tidle, time in idle state [s]; Pon-off, power
required to switch the machine off and on again [kW]; ton-off, time passed to switch the machine
off and on again [s]; Pstandby-idle, power required to switch the machine between idle and standby
state [kW]; tstandby-idle, time passed to switch the machine between idle and standby state [s];
Pstandby, power required in standby state [kw]; tstandby, time in standby state [s].  
Considering now the energy policies created for a single machine we can quote Frigerio and Matta
[42], our work being inspired to Rapuzzi’s [2] thesis that based it on their work to start her thesis.
In the article of 2014 “Energy Saving Policies for a Machine Tool with Warm-Up, Stochastic
Arrivals and Buffer Information” the two authors introduce 5 energy policies considering an
M/M/1/K system. The machine is controlled by activating a transition from the on-service to the
out-of-service state (switch-off command) based on a time threshold toff. A second transition from
the out-of-service to the warm-up state (switch-on command) is activated when the queue has
accumulated to level N or according to a time threshold ton.
Policy 1: if the buffer is empty, switch off the machine after a time interval toff has elapsed from the
last departure. Then switch on the machine when the number of parts in the queue reaches a proper
level N or after a time interval ton has elapsed from the last departure, i.e. when ton toff has elapsed
from the switch-off command.
Policy 2 (Always on): stay in on-service state after the departure of a part.
Policy 3 (Off): switch off the machine after the departure of the last part in the station.
Policy 4 (Switching): switch off the machine after a time interval toff has elapsed from the last
departure. Then switch on the machine after a time interval ton has elapsed from the last departure,
i.e. after ton toff from the switch-off command or when a part arrives.
Policy 5 (N-Policy): switch off the machine upon departure of the last part in the station. Then
switch on the machine when the queue has accumulated to level N.
25
After this consideration it is necessary to describe Rapuzzi’s study [2]. In her thesis she proposes
three energy policies to be considered in a production line with the aim of reducing the idle time in
the machines transforming it, where possible, into standby time. To better explain her work we
consider Gantt's diagram below:
Figure 2–4: CNJA Policy [2]
In this graphic it is possible to visualize the jobs j that each machine i must work in a given instant
of time. Each machine can process a job at a time and assumes the transportation times on buffers to
be equal to 0, so it is fair to say that in normal conditions the exit time of job Xij will be the entry
time of the same job j on machine i+1, if it is not processing another job. Nevertheless it is clear
from the graphic as well that the machines sometimes have to wait for a long time for the next job.
Observing the graphic for example, at the time t=0 the machine M=2 has to wait for a time t* before
processing the job. During this time span the machine M2 stays in idle state until the arriving of the
job. Let’s assume that t* is greater than the ‘break-even time’, i.e. the minimal time that makes it
convenient to put the machine in standby, as the power spent in idle for the correspondent time span
is higher than the power spent in machine switching off and on to/from a low power energy state
(Mouzon et al. 2007). In this case it would be convenient to immediately switch off the machine as
it would imply an energy saving. Machine 2 could be in standby state until t*-ttrans, where ttrans
represents the time needed to the machine for the switching on. Starting from this observation
Rapuzzi arrives at the first energy policy considered, renamed CJA (Current Job Aware), as
machines base their decisions about their energy state on the awareness about their Current_job.
26
CJA allows the machines to make decisions regarding their energy state immediately when they
finish working a job thanks to the ICT infrastructure giving real-time information.
Still considering the same situation presented in figure 2-4, let’s suppose that t* is not long enough
to put the machine in standby state; so, according to the first model, the machine 2 should stay in
idle all along t*. Though, looking at the chart, we can notice that the machine 2 after having
produced X12 will have to wait for the release of X21 to start processing it, thus having to choose
once again to go to standby or stay in idle for t**.
X12 does not need to be processed immediately at t*, but could probably easily be processed later
without affecting the total throughput. For example, it could be started at t***, defined as the
completion time of X21 minus the processing time of X12. Doing so, the machine 2 will have an
opportunity window for a longer time t***, which has more chances to be larger than the break-
even time compared to t* and to allow the machine to go to standby.
These observations have led to the definition of Rapuzzi's second energy policy, named “CNJA”
(Current and Next Job Aware): each machine gets information about the two next jobs it most likely
will have to process and makes decisions according to what it is told about. So the second energy
policy is an improvement of the first one, as a matter of fact with CNJA she does not consider only
the condition of the first one asking information about the first job that is arriving but she also
27
considers another condition asking about the job that arrives after the first job: in this way it is
possible to switch the machine in standby longer than in the first case thus saving more energy.
Starting from this policy, Rapuzzi elaborates the third energy policy, named CNJNBA (Current and
Next Job and Next Buffer Aware) in which the machine taken into account not only controls when
the next 2 jobs to be processed arrive, but also controls if the buffer after the machine has enough
room to contain the next job to be processed. Let’s imagine that under the CNJA policy, machine i
has gone to standby because it has had the information that its next job would arrive in a time
t*>TT threshold time (break-even time) and it decides to switch-on just ttrans before the arrival of its
next part in order to be operational at the right moment. After having completed the switching- on it
processes its job, but when this one is finished, the machine realises that the part cannot be loaded
down as there is no room in buffer i. This would mean that the machine i could have remained in
standby state longer, without affecting the total throughput, and avoid the idle period caused by the
blocking of the system.
Our work is precisely based on the policies she has elaborated and in the following chapter we show
how it is possible to adapt her considerations to a job shop system where the physical and
informatics flows do not follow a single direction but are twisted and follow n possible directions.
As we previously said the authors when considering different situations make the decisions about
the production planning and scheduling through statistical models with for example stochastic inter-
arrival times and job arrivals. Rapuzzi instead in her thesis uses the real-time information to make
decisions about the status of the machines. This is the way we would like to follow, we also
consider Cyber-Physical System, and so we want the machines and the stages of the production
system not only to communicate and give each other information, but also to make considerations
autonomously and so to make decisions about what to do.
2.4 State of Art of IT Enabling
In the last few years the trend about taking real time solutions has been developed and in particular
way cyber-physical systems have been considered by some authors.
Cyber-Physical Systems (CPS) are integrations of computation with physical processes. Embedded
computers and networks monitor and control the physical processes, usually with feedback loops
28
where physical processes affect computations and vice versa [44]. The system is composed of
physical elements characterized by computational capacity, communication and control capacity.
CPS will transform the interaction of engineered systems, just as the Internet transformed the way
people interact with information. In manufacturing CPS can improve productivity and quality
through smart prognostics and diagnostics utilizing big data from different networked sensors,
machines, and systems. Each physical component and machine will have a twin model in cyber
space. Each component and machine can predict and prevent potential failure and further self-
aware, self-predict, self-compare, and further self-reconfigure, and self-optimize for robust
intelligence and performance. Jay Lee et al. [45] propose an interesting framework about Cyber-
Physical System Value Proposition in which they classify the capability of this new technology.

Figure 2–6: Jay Lee Model representation [45]
Smart Connection Level: from the machine or component level, the first thing is how to acquire
data in an efficient and reliable way. It may include a local agent and utilize a communication
protocol for transmitting data from local machine system to a remote central server.  
29
Data-to-Information Conversion Level: in an industrial environment, data may come from different
resources, including controllers, sensors, manufacturing systems (ERP, MES, SCM and CRM
system), maintenance records, and so on. These data or signals represent the condition of the
monitored machine systems, however, this data must be converted into meaningful information for
a real-world application, including health assessment and fault diagnostics.
Cyber Level: once we can harvest information from machine systems, how to utilize it is the next
challenge. The information extracted from the monitored system may represent system conditions at
that time point. If it can be compared with other similar machines or with machines in different time
histories, users can gain more insight on the system variation and life prediction. It is called cyber
level because the information is utilized in creating cyber avatars for physical machines and
building a great knowledge base for each machine system.  
Cognition Level: by implementing previous levels of CPS, it can provide the solutions to convert
the machines signals to health information and also compare with other instances. In cognition
level, the machine itself should take advantage of this online monitoring system to diagnose its
potential failure and aware its potential degradation in advance.
Configuration Level: since the machine can online track its health condition, the CPS can provide
early failure detection and send health monitoring information to operation level. This maintenance
information can be feedback to business management system so that the operators and factory
managers can make the right decision based on the maintenance information. At the same time, the
machine itself can adjust its working load or manufacturing schedule in order to reduce the loss of
the machine malfunction and eventually achieve a resilient system.  
2.5 Gaps Definition
The above mentioned observations are fundamental to understand which direction we shall move in
and thanks to all the researches we have carried out we are able to define the gaps of research from
where to start:
The job shop with the relevant energy policies is not analysed deeply in literature
The existing policies so far do not take into account the ICT infrastructure that allows real
time communication
30
Although in the last few years the number of published articles dealing with energy efficiency in the
job shop has increased, they are fewer than those relative to the other configurations and in
particular there is a shortage of models that consider all the aspects, time, scheduling and energy
problems implied in this type of system. We have observed that the various authors tend to focus on
a single problem omitting some elements of the entire system. The reason of these choices is due to
the fact that in so complex a system like the job shop there are a lot of aspects that shall be
considered and sometimes, depending on the purpose of the article, it is not necessary to
contemplate them all. In view of these considerations we have decided to give our contribution in
this very area of research trying to create a situation as close as possible to reality.
We have decided to analyse the production system with job shop configuration not only because it
is less studied but also because through this type of production it is possible to analyse a more
complex production system where the layout is composed of stages and within each stage there are
more machines.
The purposes we want to pursue are two: first of all we want to increase energy efficiency in a job
shop production system considering energy consumption as the sum of the energy consumed during
the processing time, during the standby and idle state and the time in which the machines go from
idle to standby state and vice versa. Mouzon et al. [41] for example take into account the possibility
only to switch on/off the machines when it is economically convenient, since we consider also the
standby energy state in our work we prefer not to completely switch on/off the machines but to put
them in standby.
At the same time we shall not forget the makespan defined as the completion time of the entire
portfolio since we can talk about energy efficiency if the total consumptions are really inferior to
those of a base case with equal makespan or in any case if the variation in percentage of saved
energy is higher than the percentage increase of the completion time of the jobs to be processed.
Therefore we want to study the energy policies that can be applied to the job shop system to be able
to reach the above mentioned aims. So to fill the gaps we had to rely on already existing energy
policies we have described in the previous paragraph.
31

3. RESEARCH FRAMEWORK

3.1 Introduction

Before starting to explain the work carried out to fill the gaps individuated in literature, we want to
define the approach and the method we have applied in our thesis.
There are different research approaches that can be used and the aims can be different. There is the
descriptive approach where, as its name suggests, a determined situation is just described; the
analytical one where an analysis is carried out on the basis of available information; modelling and
simulation for which it is necessary to define and implement a series of rules. We have an applied
research if it is focused on a specific situation, on the contrary if the situation can be generalized it
is a fundamental research. The research can also be classified in quantitative and qualitative
research, in the first case the phenomena and consequent output are measurable, in the second case
they are not measurable; besides if the research is relative to abstract concepts and theories it is
defined as conceptual whereas if it implies analyses which lead to conclusions that can be verified it
is empirical.
Our work can be classified as analytical and fundamental since considerations and analyses on a
generic production system with job shop configuration are carried out; actually during the
simulation a well defined system is taken as an example, but the proposed energy policies and the
observations made are adaptable to any job shop as far as both the layout and the machines and
parts characteristics are concerned. Besides our research is quantitative and empirical since our aim
is the calculation of the saved energy considering the obtained makespans.
To carry out our thesis it has been necessary to follow a structured approach and precise
methodological steps and we refer to the text “Modellazione dei sistemi produttivi” written by
Marco Macchi and Sergio Terzi in 2009 [1].

3.2 Research Environment

The aim of our thesis is supplying energy policies to carry out in a production system with job shop
configuration. First we had to carry out a careful research on the issue of energy efficiency in
32
manufacturing and then define the gaps in literature and consequently define the specific area to
analyse.
The scheme below (figure 3.1) shows where our work can be placed.
The level we want to focus on is the manufacturing system level and in particular we have created
energy policies that can be adapted to a system with job shop configuration. We talk about energy
policies since our work is based on a sustainable approach with the aim of reducing energy
consumption to obtain economic savings on the one hand and reducing CO2 emissions in the
environment on the other hand. As a matter of fact our work contributes to environmental and
economic sustainability and is coherent with the research trend of the last few years: the shortage of
resources, the increase of the costs for the raw materials extraction and climate changes have led to
an increased interest in the environment and to the definition of strict regulations and standards.
These aspects have encouraged the industrial sector to undertake activities aiming to energy
efficiency.
The activities in manufacturing are characterized by three main drivers: cost, time and quality;
actually production planning is carried out with the triple aim of reducing costs, decreasing working
time and increasing quality (or reducing faults). The element we consider more in our work is
production cost; in fact we want to reduce energy consumption limiting the impact on the total
production costs and consequently the energy total cost.
This scheme starts from the creation of conceptual models we describe in detail in chapter 4,
afterwards we develop the communicative model that in our case consists in the formulation of a
code to install in the simulator. The implementation of the models takes place in the simulation
phase where after a series of experiments it is possible to make some considerations as shown in
chapter 6. To verify that the policies we have considered effectively lead to savings in terms of
costs and energy consumption each activity is supported by key performance indicators.
33

Figure 3–1: Representation of conceptual model creation. [46]
3.2.1 Research Questions and Objectives

After having analysed literature in detail we can formulate the main research questions:
-‐ RQ1
How can the energy efficiency of a job shop production system be improved applying the
Current Job Aware and Current and Next Job Aware energy policies that have been designed
for a line production?
First it is necessary to study the complexity of a job in detail and then adapt the policies to the job
shop itself, considering the system no more as a single flow in a single direction but as a system
with n directions. For this reason it is not possible to talk about “previous” or “following” machine
in general but it will be necessary to refer to the path of a specific job.
-‐ RQ2
34
To be able to use ICT technologies it is necessary to manage the real time communication among n
stages, understanding what information to obtain, in which moment and how to use it to apply the
energy policies of the first research question.

3.2.2 System Definition
The aim of this work is to fill the above mentioned gaps analysing a more complex system such as
the job shop later including generic machines.
To reach this goal we have decided to study a system with three stages since two would not be
enough to create paths whereas four would be redundant. The machines of each stage have been
analysed both from a production and an energy point of view. Barletta in his thesis written in 2012
“Una Metodologia Cross View di Sviluppo di Key Performance Indicator di Efficienza Energetica”
describes the energy states giving also information about the qualitative trend in the course of time
of each energy state as shown below [47].
Energetic status Description Costant in time Variable with time
Off No power consumption. X

The machine is off
Ramp-down Decreasing with time. X

Phase from standby to idle
state
Idle All auxiliary components X

are active and the machine
is ready to work, but it is
waiting for a piece to work
because of some
managerial on maintenance
problems
Maintenance Energy used by the X

machine during the
maintenance program,
which implies an energy
35
consumption. As energetic
xstate it is the same of the
standby one, but it is
important to make a
distinction between the two
different reasons which
lead to it
Standby Less energy-consuming X

than the idle one, most of
all in firms who care more
about the energy-saving
subject.
Set-up Energy used in the set-up X

state, mostly for the
machine tool changing
Ramp-up Machine turning on. The X

power profile is increasing
until a peak Pmax; before
that, it goes down to a
constant value Plow
Processing (working) Energy spent during pieces X

processing. It’s the most
energy-spending state,
including material removal,
machining, movements and
energy used by the
auxiliary components
Figure 3–2: Energy states description [47]
As we will explain later, as for the ramp up and ramp down power we have approximated to be able
to work with the simulator.
The whole topic will be further analysed in chapter 4 “Conceptual Models”.
3.3 Research Methodology

To be able to fill the gaps in literature and reach the proposed targets we have followed the
methodology proposed by Marco Macchi and Sergio Terzi [11] in the text “Modellazione dei
sistemi produttivi” written in 2009. The authors explain that execution of a simulation project shall
36
be based on an iterative process whose fundamental steps are:
1. Problem knowledge
2. Conceptual model
3. Coding of the model and software
4. Attainment of a solution and/or understanding of the system
Repeating the process more times it is possible to obtain a better solution reaching a better
knowledge and understanding of the process as well.
A detailed description of the steps is in the chapter dealing with simulation, nevertheless in the
following paragraphs we give a short description of the different steps.
3.3.1 Problem Knowledge

First of all it is necessary to know the problem considering what we are going to observe and
simulate, how we are going to proceed, what the motivations and limits are. It is then necessary to
analyse the literature which has been published so far particularly focusing on the sources that need
to be distinguished to individuate everything which is relevant to the scientific issue we are dealing
with. This step can have a double aim:
1. It is necessary to verify if the issue has been already dealt with
2. The already published literature is an important source for the knowledge.
Chapter 2 deals with these two aims.
3.3.2 Conceptual Model

This phase is fundamental to have a clear vision of the system. Our work contemplates the
implementation of some energy policies for a job shop system to be compared to a base case. Then
we have developed a conceptual model relative to the base case taken into account and conceptual
models to describe the implemented energy policies. With our models it has been possible to define
what we are going to do step by step during the production process, the various decisions to make
as for the system, the single stages and machines as well as the interactions and communication
between the different objects making up the system.
All the models which have been elaborated are detailed in chapter 4.
37
3.3.3 Coding of the Model and Software

This is the most technical phase, in fact it is necessary to transform the conceptual model into an
algorithm which can be read by the simulator chosen for the experiments, in our work we are
using Tecnomatix-PlantSimulation v12 by Siemens.
3.3.4 Attainment of a Solution and/or Understanding of the System
Once the code has been written, it is put in the simulator and all the experiments are carried out.
During this phase different simulations have been carried out taking different situations into account
as described in chapter 6.
After the implementation some indicators of performance are chosen to be compared to the base
case in order to be able to verify or reformulate the model.
The figure below summarizes the iterative process developed by Macchi and Terzi. [1].

Figure 3–3: Steps to follow for a simulation project [1]

38
4 MODEL DEVELOPMENT
4.1 Production Planning
Figure 4–1: General architecture for the production planning [2]
The scheme above represents the hierarchic architecture of the planning process. The level we want
to focus on is the last one; actually in this phase real time choices are made according to the
instantaneous development of the production system. The operations characterizing this phase are
the choice of the job to be loaded in the system (loading), the choice of the moment in which a new
39
job is loaded in the system (timing) and the operational sequencing. This last operation includes the
routing that is the choice of the physical machine that must work a certain job and the dispatching
during which, once the jobs are in the queue, it is to be decided what job has to be worked first
according to a priority rule.
From the software architecture point of view the real time control system can be described in three
modules that must interact with each other:
-‐ The planning process that includes the part programs that are all the instructions to give to
the devices of the different machines to carry out the manufacturing. It interfaces with a
static technological database that contains information about the production cycles of each
job.
-‐ The production scheduling that is the module that allows the transformation of the
Production Planning System (PPS) and the generation of the short-term production
planning. It is the module that allows to carry out the above mentioned operations
interfacing with the production management system through a production orders database
that contains the frozen plans.
-‐ The process control and monitoring that is the module that must make decisions in real time,
reads what must be worked in its memory and where manufacturing must take place and it
operates in real time. It is subdivided into seven software modules, each one with its own
function that are operated through a module called executive that synchronizes all the
modules with a series of tables contained in the control central computer. There are state
tables of the peripheral units in which the state of the devices is indicated, as well as the
starting time of the processing and the ending time so that the other modules can interface
with the executive thus having all the information available. Besides there are state tables of
the parts that indicate the jobs there are in the queue at the machines and those in production
and operations tables that show what operations are in progress, what machines are carrying
them out and what jobs are being worked.
The other six modules making up the process control and monitoring are scheduling, direct
numerical control, material handling, tool management, quality control, monitoring and factory
interface.
40
4.2 Conceptual Model
As shown in literature, before being able to develop a software model and start carrying out
experiments it is necessary to develop conceptual models. This formalization is fundamental to
have a clear vision of the problem and its limits. The logical model is the “frame” of the simulation.
Nothing can be planned on the computer if the objective is not clear before. In this regard it can be
useful to reconsider the research questions we focused on for this thesis, as already described in
chapter 3.
-‐ RQ1
How can the energy efficiency of a job shop production system be improved applying the energy
policies developed by Rapuzzi in her thesis “Energy-aware control policies for autonomous
machines in a flow-line”?
To reach the target and thus adapt the energy policies to a job shop system it is necessary to
consider and study the complexity of such a system thoroughly. It is necessary to analyse the
system considering it not as a single flow in one direction but as a system with n directions to
analyse.
-‐ RQ2
How can ICT technologies be exploited to efficiently manage a job shop system?
The main concept is the one of real time among S stages; as a matter of fact it is important to
understand what information to obtain, in which moment and how to use it to apply the energy
policies of the first research question.
4.3 System Description
It is very important to describe and analyse the job shop system first. As already explained
according to the authors Damiano Milanato and Roberto Pinto [48] this system is characterized by
stages where there are technologically homogeneous machines suitable to carry out a specific phase
of the production cycle for a certain group of products.
41
Our production system is characterized by input that introduces the jobs in the system, three stages
and the output. Each stage contains a buffer that is linked to two identical machines that can process
the jobs.
We have hypothesized to have six different kinds of jobs that will visit the machines in different
sequence.
It is important to underline that there are two flows to be considered: a flow of jobs that visit the
machines and an information flow. The production flows are generated by the movement of the
materials inside the system and the information flows consist of all the information that are
necessary to support production.
The first image identifies the flow of the jobs inside the system we would like to analyse. It might
seem not very clear therefore a short description is necessary. Three arrows starting from the input
identify the three directions the jobs can follow once in the system. According to the type of job
taken into account the input system will send it either to the stage A (purple) or to the stage B
(orange) or to the stage C (green). Once the job has been worked it can enter one of the other two
stages or, if its processing is over, the output, going out of the system.
Figure 4–2: Representation of the jobs flow in the system
Once the job is in one of the stages, it enters the buffer of the stage itself and in this moment the
machine where this job will be processed is chosen. This step is essential for our work because in
this way we can choose the machine that has to work according to its energy state and consumption.
42
In fact since we do not work with a production line we have introduced a model for the allocation of
the jobs in the different machines.

Figure 4–3: Representation of a generic stage
As for the second flow that represents an essential element in the production system, in this thesis
we have decided that the information communication does not take place between the machines, as
it is the case of Rapuzzi's work [2], but between stages. Therefore in our case there are no devices
on the machines that communicate with each other, but it is the controlling computers that are
located inside each stage that interact; in fact they gather information about the jobs to be worked,
the timing and the machines energy state and they not only elaborate it to make decisions in the
stage, but they communicate it according to the specific requests of the other stages. This is an
important step in the development of the conceptual models and we consider this type of
communication to be more efficient, easy to develop and suitable for our needs.
The scheme represents the information flow. As it can be seen the arrows are bidirectional because
communication arrives from both sides and they go into the “centre of the stage”. In this way we
want to represent the fact that the stages communicate what they are doing in a certain moment and
they make real time decisions concerning their machines according to the information they have
collected.
43
Figure 4–4: Representation of the information flow in the system
4.3.1 Input
The input introduces 3,000 jobs into the system following the criterion of loading at random. The
random sequence is maintained identical during all the experiments in order to be able to make
comparisons as for performance. This criterion generates a rate of saturation that is continually
floating because in case the jobs chosen at random are “correct” the rate increases, otherwise it
decreases. We have chosen this rule in order to try to interfere in the process as little as possible.
The 3,000 jobs are produced by the input and are all introduced into the system at regular intervals
that we have decided to vary during the experiments we carried out to try to analyse as many
situations as possible.
No power has been associated to the input because the objective of this work is not to calculate the
total energy consumption but the savings linked to the implementation of the energy policies. For
this reason a power linked to the input would not have been differential.
44
4.3.2 Buffer

We have located only one buffer for each stage and in order to simplify the problem, otherwise too
complex, we have considered all the buffers with as many positions as the jobs are in order to avoid
problems of blocking. We have chosen the FIFO criterion as dispatching rule. This method
contemplates to first process the first job that arrives.
No power has been associated to the buffer, because also in this case it would not have been
differential.
4.3.3 Machines

As for the machines, we can describe them both from a production and energy efficiency point of
view. In literature particular attention has often been paid to the production states and since in our
work we have repeatedly underlined that the machines energy states are essential for this work we
want to distinguish them in detail.
Considering the machines from a production point of view, the states can be the following:
-‐ Working: in this state the machine is working a job;

-‐ Idle: the machine is ready but has no job to work;
-‐ Setup: the machine is being prepared to be able to work the next job (for example the
change of a tool);
-‐ Maintenance: the machine is undergoing preventive maintenance or is being repaired after
a failure;
-‐ Failure: the machine is in failure state. There are different types of failure, some failures
slow the machine down, others stop it;
-‐ Off: the machine is off.
In our work the machines are considered in working or idle state.
Considering the machines from an energy point of view we can identify the following states:
-‐ Working: the machine is working a job and this state requires more power;
45
-‐ Idle: the machine is ready to work but has no job. The power required for this state is
inferior to the necessary power for the working state.
-‐ Standby: the machine is not ready to work because most of its components are off.
Nevertheless the machine is not off therefore there is energy consumption to supply those
components that are still on;
-‐ Maintenance: the machine is being repaired and requires a certain amount of power;
-‐ Ramp-up: It is the transitional state from standby to idle state. To activate the components
of the machine power is therefore necessary;
-‐ Ramp-down: It is the transitional state from idle to standby state.
These last two states are transitional states that allow to describe the energy consumption behaviour
of a production machine more realistically, which can be represented as shown below:

Figure 4–5: Power profile of a production asset [46]
Anyway it is not always easy to take this transitional states into account. For example with the
Tecnomatix Plant Simulation version 12 simulator we have chosen it is not possible to calculate this
power precisely. The simulator uses approximations, in fact it is possible to input the time relative
to the ramp-up and ramp-down but not the power absorbed by the machines in these two moments.
For this reason for the calculation the simulator considers the highest power of the two transitional
states. For example a production machine characterized by a tramp-up=10 sec that from the standby
phase (Pstandby=2 kW) must pass to the idle phase (Pidle=4 kW) will consume power:
Eramp-up= tramp-up * Pidle =10 sec*4 kW= 40 kWs
Equation 6: Example of energy consumption
46
In this case therefore, considering the figure, there will be approximation.
.

Figure 4–6: Approximated power profile of a production asset [46]
Nevertheless the subdivision between energy and productive states of the machines is very
important, above all if we think that the relation between productive and energy states is not one to
one. A deeper examination of this issue is given by the article “Multi-objective genetic algorithm
for energy-efficient job shop scheduling” written by Gökan May, Bojan Stahl, Marco Taisch and
Vittal Prabhu [49]. In fact for example an off, idle or standby energy state can correspond to the idle
productive state.
The image summarizes the relationships between the productive and the energy states.
Figure 4–7: Links between productive states and energy states [37]
47
4.4 Conceptual Model –Base Case
As already anticipated in paragraph 4.1, a conceptual model is a simplified representation of the

production process useful to analyse and measure sets of significant aspects in order to be able to
make the necessary decisions to carry out the production process coherently with the objectives. All
the information relative to the productive and economic aims as well as the current state of the
system shall enhance the process model that will make decisions about the controlled dependent
variables: they are the output of the control process model and are defined dependent because their
value depends on the control operations. They have to be distinguished from the non-controlled
independent variables: process variables whose value depends on other process variables that can
be controlled.
There are several types of process models. According to the type of model we can distinguish:
-‐ procedural models based on a series of procedures, often if – then, built on a process
description;
-‐ calculation models based on mathematical, analytical and statistical relationships that
describe the process.
In the course of the years the process models have evolved:
-‐ In the 1960s above all mathematical models were developed that presumed the knowledge
of physics, dynamics, kinematics and statics of the processes on which the models had to be
built. The limit of these models is the difficulty in extending the process control to other
production systems that are not thoroughly known.
-‐ In the 1970s empirical-statistical models were used that did not represent a phenomenon
through the physical knowledge of it but through the reconstruction of an empirical law that
ruled it thanks to statistics and regression techniques. The disadvantages of these models
were linked to difficulties and implementation costs.
-‐ The 1980s were characterized by the use of the inferential models. The know how was
obtained from those people that for years had been manually managing the processes. The
most important and interesting parts of know how necessary to the automatisation of the
control were the cause and effect relationships that occurred in the processes. Nevertheless
the operators were not able to supply these relationships.
48
There are different languages and diagrams that can be used to create a conceptual model. There
is not an absolutely best modelling method or language, it depends on the context and the
objective to be reached. The most used languages are:
-‐ ASME diagram of the production processesà It provides for the use of simple symbols,
such as the circle to represent a working phase, the triangle for the waiting phase, a square
for the controlling phase and an arrow for handling and transport. This typology is usually
used for the logistics of an industrial process;
-‐ Business process model and notation (Flow chart)à BPMN is a standard for business
process modeling that provides a graphical notation for specifying business processes in a
Business Process Diagram (BPD), based on a flowcharting technique. Flow chart uses the
symbol of an ellipse to indicate the points of beginning and end, the rectangle for the
processes, the parallelogram for input/output operations and the rhombus for the decisional
points. This language is particularly useful to represent both the information and the
physical flows;
-‐ Event process chainà it uses hexagons for the events, rounded rectangles for the activities,
circles for the organizational resources and rectangles of the information resources.
We had to define different conceptual models to be able to describe the work. First of all it is
necessary to describe the conceptual models that describe the base case and later enrich them to
describe the implemented energy policies.
In the models the colour red has been used to identify the decision of putting the machine into
standby mode, yellow to highlight the decision of keeping the machine in idle mode and green to
highlight the decision of switching the machine on.

In the base case the input introduces the 3,000 jobs into the system that are processed in the stages
according to the assigned sequences. The jobs, once arrived in the buffer, are sent to the machines
of the stage without a particular policy but they will simply go to the first machine available. All the
machines are always on, their possible energy states are idle or working state and they never go in
standby because there are no energy policies.
The conceptual models describing the base case are just two:
49
- input behaviour;
- stage behaviour.
When the job j arrives the input must read the operations table to understand where to send the job.
In the first column of the table there are the 3,000 jobs that shall be processed, in the second
one the type of the corresponding job. The columns identified with “1”, “2” and “3” identify
the first, second and third operation that must be carried out on the job and thus indicate the
sequence of visit to the stages for each job. In particular we have established the path of each
job and for example as shown in the table, the Entity1 first visits the stage A, then B and
finally C.
Table 2: Operations table
50

Figure 4–8: Representation of the source conceptual model
where:
• j: job in the input to be worked;

• o: operations o=1...O;
• k: stages k=1…S.
When the job j is in the input, the input must read the table, more precisely it must read [j;o]. The
index “o” is initialized at 1, because after the input the jobs undergo a first operation. The input
after reading the table and individuating the first stage the job j has to visit, sends it to the
corresponding buffer.
51
The first part describes how the stage behaves when a job arrives in the buffer and then explains
how the job is assigned to a machine, whereas the second part explains how, once the job has been
worked, it is sent to the next stage. Therefore it is possible to individuate two events that activate
these processes:
-‐ the job j arrives in the current buffer;

-‐ the job j has been worked.
Figure 4–9: Base case conceptual model
52
Where:
-‐ i: machines i=1…M;

-‐ M: total number of machines for each stage;
-‐ j: job to be worked;
-‐ k: stages k=1…S;
-‐ o: operations to be carried out o=1…O.
The model activates itself when the job enters the buffer of the stage: the stage must choose the
machine that has to process the job.
In the base case, while the stage makes this decision it does not control the energy state of the
machines but only checks if the machine is working or is in idle state and thus available to receive
another job. In this way the job will go to the first available machine. The first question of the stage
is: “Is the machine Mi in idle?”, in case the first machine is not in idle, it is necessary to control the
other machines. While the machines are controlled the index i is incremented by 1 up to, if
necessary, i=M where M is the total number of the machines of the stage. Every time the answer to
the question is negative, the index i is compared to the maximum number of machines for each
stage. If the index i is inferior to M it means that not all the machines have been controlled therefore
i is implemented and the operation is repeated. In case i=M, it means that the stage has controlled
all the machines in the stage and that in this moment none of them is in idle and therefore the job
will stay in the buffer, after which the index i is initialized at 1 and the machines are controlled
again. Instead if the answer to the question “Is the machine Mi in idle?” is yes, the job will be
worked by Mi.
53
Figure 4–10: Base case conceptual model
Where:

54
-‐ o: operations to be carried out o=1…O.
Every job has to follow a determined path shown in the operations table according to its typology.
Thus when a job is completed by a machine it has to go to another machine to be worked or it has to
go out of the system. After each operation the table is updated and the operations indicator is
increased by one to identify the next operation the job is to undergo or to decide if the job has to go
out. The index of the operations must be compared with the maximum number of operations that
have to be carried out. If o=O it means that the job has been completed and therefore will go to the
drain, otherwise the stage, reading the operations table in [j;o], will see what machine the job has to
go to.
This conceptual model is read whenever a machine completes an operation.
4.5 The Manzone Nervi 1 Policy
The above conceptual models shortly describe the base case, in which the job shop functioning is
simply modelled without energy policies. The aim of this work nevertheless is to introduce energy
policies in this production system to obtain energy savings.
The policies we want to introduce are “Current Job Aware” and “Current and Next Job Aware”,
respectively called CJA and CNJA, developed by Nicole Rapuzzi for the first time [2].
According to the first policy each machine has to go in standby if no job to be worked arrives
within a certain threshold time. The machines turn on at a defined time: t* - tramp-up
The rule that is explained in detail in chapter 2.3.3 can be summarized as follows:
1. If the arrival time of Current_job t* ≥ Threshold Time, then go standby
→ Plan to switch-on at: t*-tramp-up (to be operational when the job effectively arrives)
Where:
-‐ t* → arrival time of “current job” at the machine
55
In this way the saved energy is equal to :
tidle * Pidle – ( tramp-down * Pramp-down + t standby * Pstandby + tramp-up * Pramp-up)
Equation 7: Saved energy equation [2]
Where:
-‐ tidle → time spent by the machine in idle energy state;

-‐ Pidle → necessary power for idle ;
-‐ tramp-down, tramp-up →necessary time for the machine to pass respectively from an idle energy
state to standby and vice versa;
-‐ Pramp-down, Pramp-up→necessary power for the machine to pass respectively from an idle
energy state to standby and vice versa;
-‐ tstandby →time spent by the machine in standby energy state;
-‐ Pstandby→necessary power for standby;
To be able to adapt the policies as well as possible it has been necessary to study the threshold time
to understand how we can define it in our case. Gilles Mouzon, Mehmet B. Yildirim, and Janet
Twomey [50] define the threshold time as:
Equation 8: Threshold time equation [50]
The use of this formula is limited to the cases where the arrival time of the jobs is superior to the
time requested to turn the machines on and off. In fact the authors with this formula consider the
phase of turning on and off, whereas we want to take into account the ramp-up and ramp-down
phase, thus we adapt the formula as follows:
𝑃?Gc>B> ∗ 𝑡?Gc>B> + 𝑃?Gc>A@eF ∗ 𝑡?Gc>A@eF

𝑇𝑇 =
𝑃EAHI
Equation 9: Threshold time formula adapted by Mouzon et al. [50]
56
This formula has been retaken by Rapuzzi in her thesis:

Equation 10: Calculation of the threshold time [2]
where the time of ramp-up and ramp-down are multiplied by the differences between the respective
powers and the power during the standby phase and at the denominator there is the saved power.
In order to try to explain how we have decided to adapt the formula to our case a short description
of the simulator is necessary. In fact in the simulator we are using, Tecnomatix Plant Simulation, it
is possible to introduce the powers relative to the working, idle, standby and off phases but not
those relative to the transition phases, such as ramp-up and ramp-down phases, for which it is
possible to introduce only time. The simulator approximates as for the powers, as explained in
paragraph 4.3.3 of this chapter, taking the highest power of the two transition states, therefore in
this case it will approximate to the power of the idle phase.
Reconsidering now the formulas and considering the simplification of the simulator:
𝑃EAHI ∗ 𝑡?Gc>B> + 𝑃EAHI ∗ 𝑡?Gc>A@eF
𝜏=
𝑃EAHI
Equation 11: Formula of the threshold time [50] with simulator approximation
(𝑃EAHI − 𝑃hDGFAiK ) ∗ 𝑡?Gc>B> + (𝑃EAHI – 𝑃hDGFAiK ) ∗ 𝑡?Gc>A@eF

𝑇𝑇 =
(𝑃EAHI − 𝑃hDGFAiK )
Equation 12: Formula of the threshold time [2] with simulator approximation
it is easy to note that the powers can be simplified and therefore the threshold time will simply be:
𝑇𝑇 = 𝑡?Gc>B> + 𝑡?Gc>A@eF
Equation 13: Final threshold time
Going back to the drawing up of the first energy policy, it has been necessary to extend the
conceptual models seen before.
The model that describes the source behaviour remains identical and will be the same for the second
energy policy too, but the model that describes the behaviour of the machines changes.
57
The Manzone Nervi 1 policy is made of two phases: the first phase refers to the routing phase
whereas the second one refers to the process to be followed in order to choose the energy state of
the machines when they finish working a job.
The routing phase is a phase in which the stage chooses what machine the job in the buffer is to be
assigned to on the basis of the energy state of the machines.
The second phase is activated when the machine finishes working and the stage has to choose in
what energy state the machine must be on the basis of the arrival time of the next job to be worked.
Therefore the decisional events in the Manzone Nervi 1 policy are:
-‐ the job arrival time in the buffer;

-‐ the end of processing by a machine.
Figure 4-11 below represents the conceptual model of the routing phase.
58
Figure 4–11: The Manzone Nervi 1 policy, routing phase conceptual model
59
Where:

-‐ l: second index identifying the machines in a stage l=2…M;
The conceptual model starts when a job arrives in the buffer and the stage must therefore decide on
what machine the job has to be worked. In the base case this choice was not important actually the
job was simply sent to the first available machine. This decision is part of one of the two activities
the Real Time Control System is made of: loading and operation sequencing. During the loading
that includes two phases the jobs to be loaded in the system are chosen. The two phases are:
-‐ loading, that is the choice of the job to be loaded in the system;
-‐ timing, that is the choice of the moment in which a new job is loaded in the system.
The operation sequencing as well is composed of two phases and they are:
-‐ routing, that chooses what physical machine must work a certain job among more machines;
-‐ dispatching, where the job in the queue that has to enter the machine is chosen. A criterion is
followed to decide what job among those in the queue must be processed.
This first part of the conceptual model explains the routing phase which is used; in Rapuzzi's CJA
policy this step does not exist since a production line is studied and therefore there is not the
problem of choosing the machine. This step in a job shop production system is essential and
represents our most innovative contribution to the research, this is why it must be described in
detail. Always pursuing the objective of energy efficiency when the job arrives in the buffer we
prefer it to be worked by a machine in idle since it is already available. If there are no machines in
idle, we prefer it to be worked by a machine that ends its work in a time which is inferior to the
threshold time defined as the sum of tramp-up and tramp-down that is the necessary time for a machine in
standby to go to idle state and vice versa. If there is a machine that finishes working within the
threshold time, the job has to wait for this machine in the buffer; in fact in this case we have not
decided to switch another machine from the standby to the idle state because we prefer not to stress
the system. Otherwise if there are no machines that are finishing within the threshold time it is
necessary to switch a machine from standby to idle state.
60
Summarizing therefore the stage shall control:
-‐ first if there are machines in idle;

-‐ then if there are machines that are working but will be finishing within a certain period of
time (threshold time);
-‐ eventually if there are machines in standby.
The above mentioned conceptual model describes this mechanism. The input sends the job j to the
current stage and the current stage starts to read the conceptual model. The current stage reading the
table controls the state of the machines. The first question of the stage is: “Is the machine Mi in
idle?”; the question is repeated for all the machines in the stage. In case the answer is always “no”, i
is reinitialized to 1 to check all the machines again, but during this second iteration the question
becomes “Is Mi working?”. As already explained it is necessary to control how long it takes to
finish working, the finishing time in the conceptual model is called tend and has to be compared with
the threshold time. For this reason the counter “l” is introduced that is initialized to “l=i+1” to
control all the machines after the machine i taken into account (we are not interested in controlling
the previous ones because if the counter i keeps going it means that the machines that were
questioned before are not available). The stage has to compare the tend of Mi to the tend of Ml. Once
all the machines are controlled through the increasing of the index l, if the tend of Mi in inferior to all
the others it can be compared to TT. If tend of Mi is superior to TT, it is necessary to increase the
index i, analysing the next machine till i=M. The standby state is the last energy state to be
controlled. The counter i has to be reinitialized at 1 to start controlling the first machine. The
question to make this time is “Is Mi in standby?”; if the answer is “yes”, it will be necessary to turn
the machine Mi from standby state into idle to work the job j. In this case the job shall wait for tramp-
up before being worked. If the answer is “no” and iterating the counter i no available machine is
found, the job must remain in the buffer and the procedure must start from the beginning.
Below is the conceptual model of the Manzone Nervi 1 policy second phase.
61

Figure 4–12: The Manzone Nervi 1 policy, conceptual model - decisional state on a machine energy state
62
Where:

-‐ p: counter that counts the jobs in the other stages that have been completed within TT;
-‐ cont1: counter that counts the total number of jobs arriving from the stages within TT.
The current stage reads the conceptual model when a machine inside it finishes working and has to
manage the energy state of the machine itself. As a matter of fact a machine can remain in idle state
or if possible go in standby. First of all it is necessary to control if there are jobs ready to be worked
in the buffer: “Is there a job in the current buffer that has to be processed?” if the answer is yes, the
machine will certainly stay in idle, ready to receive a new job.
Otherwise the following relation must be satisfied to allow the machine to go in standby:
job arrival time >TT.
Then the current stage has to question the other stages and the input. The question is: “Are you
sending a job j to the current buffer within arrival time≤TT?”. The stages must read their own tables
to answer this question. To describe how they do, it has been necessary to describe another
conceptual model we will explain further.
In order to count the actual total number of jobs that will be sent to the current stage within the
interval TT we use a counter called cont1 that after receiving the answers from the other stages and
the input increases its value by a term defined “p”. It identifies the number of jobs that each stage
and the input send to the current stage. It is necessary to count all the “arriving jobs” because our
aim is to have as many machines in idle (and thus machines available and ready to work) as the
arriving jobs in the current stage are. So if the number of machines currently in idle is superior or
equal to the number of jobs, the machine i taken into account will be set to standby, otherwise it
will be waiting for a new job to work.
When the machine goes in standby, to simplify the conceptual model we have decided not to plan
the exit from the standby phase. When the current stage deems it is necessary for a machine in
63
standby to work a job, the machine will be turned on and the job will wait for a period equal to the
ramp-up time. We are aware that this is a limit of our model, actually to avoid the queue we have
decided to set the ramp-up time equal to 0.
We have not described how the stage is able to obtain some information yet, such as the number of
jobs that are completed within a certain time.
This operation is described by the following conceptual model that is activated whenever a single
stage (current stage) asks the other stages about their machines.
64

Figura 4–13: Conceptual model- communication in the stage
65
Where:
In order to make decisions about the energy state of their machines the stages have to communicate
with each other.
When a stage receives the question: “Are you sending a unit j to the current buffer within arrival
time≤TT?”, the stage k has to read its “own table” where all the information about the starting and
ending time of the works on the machines is shown.
If we hypothesise that in the stage k there are two machines, the table will be the following:
Table 3: Starting and ending time of the jobs in the stage
The stage k has to read the row 3 for each machine and compare this time to TT. If the time [3;Mi]
is between 0 and TT, first the stage k has to control that the job being worked after completion is
going to the current stage that made the question at the beginning, to this purpose it controls the
operations table.
Table 4: Operations table
66
The stage has to read [j;o+1]: the line j individuates the job being worked and the column o+1
represents the next operation individuating the next stage. Every time a job that is completed within
TT is individuated and has to go to the current stage that asked the question, the counter “p” is
increased. Repeating this process for all the machines in all the other stages it is possible to
individuate the total “p”.
Thanks to these conceptual models it is possible to describe the first energy policy that will be
implemented with the simulator whose results will be analysed in chapter 6.
4.6 The Manzone Nervi 2 Policy
Rapuzzi [2] has elaborated a second energy policy called Current and Next Job Aware (CNJA)
where although the job arrival time in inferior to TT the machine is not always in idle; in fact
according to CNJA it is necessary to control the second job arrival time as well. The CNJA is
described in detail in chapter 2.3.3. We can summarize it in two rules:
1. If the arrival time of Current_job t* ≥ Threshold Time, then go in standby
-‐ Plan to switch-on at: t* - tramp-up (to be idle when the job effectively arrives)
2. if t*** which is defined by the arrival time of Next_job minus the processing time of
Current_job ≥ Threshold Time, then go in standby
Plan to switch-on at: t***-tramp-up (to process the two jobs in a row)
Where:
-‐ t* is the arrival time of the “current job”;

-‐ t** is the time from the completion of the “current job” and the beginning of the processing
of the “Next job”;
-‐ t***=t* + t**
-‐ t***= (processing starting moment of the next job)- (working time of the “current job”).
According to this energy policy a machine can remain in idle if the following relations are valid:
-‐ t* ≤ TT;
67
-‐ t* + t** ≤ TT that is t*** ≤ TT.
Figures 4-14 and 4-15, already shown in chapter 2, clearly summarize the concept.

The equation shows the energy consumed with the implementation of the CNJA during t***:
68
tramp-down ⋅ Pramp-down + tramp-up ⋅ Pramp-up + (t*** - tramp-down – tramp-up) ⋅ Pstandby
Equation 14: Consumed energy [2]
The increase in energy saving compared to the first policy is given by:
(t* + t**) ⋅ Pidle – tramp-down ⋅ Pramp-down – tramp-up ⋅ Pramp-up – (t*** - tramp-down – tramp-up) ⋅ Pstandby
Equation 15: Saved energy [2]
The next conceptual model describes the Manzone Nervi 2 policy. We have modified the CNJA
policy which is used for a line production system to implement it in a job shop system.
The Manzone Nervi 2 policy, like the first one, is composed of a routing phase and a phase during
which the stage decides for the energy state of the machines inside it.
In this case as well the decisional events are:
-‐ the job arrival time in the buffer;

-‐ the end of a processing by a machine.
69
Figure 4–16: The Manzone Nervi 2 policy conceptual model - routing phase
70
Where:


The conceptual model is read by the current stage when a job arrives in the current buffer and it has
to be worked by one of the machines.
The first part of the conceptual model, that is the routing phase represented in figure 4-16, is very
similar to the first energy policy; in fact the current stage controls first of all if there are machines in
idle and then in working state, after if there are machines in standby state.
The question to ask to know if there are machines in standby is: “Is Mi in standby?”. If the answer
is yes it is also necessary to ask: “Mi’s timer=0?”.
The timer is a counter associated to each machine that indicates the period in which the machine
must be in standby and during this period its energy state cannot be modified. This timer has been
introduced since when a machine finishes working a job and has not immediately another one to
work the current stage has to decide if the machine can go in standby saving energy. The Manzone
Nervi 2 policy idea is that a machine can be set to standby instead of remaining in idle not only if
the next job arrival time is superior to TT, as the first policy contemplates, but also if the two next
jobs arrival time is superior to TT+ProcTime. The timer guarantees that once the machine is set to
standby this remains inactive at least for a precise period of time. Actually should a job arrive at the
current stage before this period is over it would be necessary to ascertain that it is not assigned to
the machine before the time established by the routing phase; in fact should the job be assigned to
the machine before the timer is reset, there would be the risk for the machine to activate itself to
work that job but then to remain in idle state to wait for another job.
When the timer is reset it does not mean that the machine goes in idle state but that it can be put in
idle state by the current stage if necessary.
So if the timer is 0 the machine can be put in idle state, otherwise the current stage has to control
the other machines.

71

Figure 4–17: The Manzone Nervi 2 policy conceptual model – decisional state on a machine energy state
72
73
74
75
Where:
-‐ i: machines in the current stage i=1…M;

-‐ h: second index identifying the stages h=2…S;
-‐ cont1: counter that counts the total number of jobs arriving from the stages within TT
-‐ cont2: counter that counts the total number of jobs arriving from the stages in the interval
time between TT and TT+ProcTime;
-‐ SumCont: counter that counts the total number of jobs arriving from the stages within
TT+ProcTime;
-‐ q: counter that counts the jobs in the other stages that have been completed within TT+
ProcTime;
-‐ Tk: arrival time of the first job that enters current stage k after TT + ProcTime;
-‐ Th: arrival time of the first job that enters current stage h after TT + ProcTime;
-‐ n: counter that counts the jobs found;
-‐ M in idle: Machines in idle state;
-‐ M in standby: Machines in standby state.
The current stage reads this conceptual model when a machine inside it finishes working a job j and
it has to choose the most economical energy state. Thus the event that activates this second phase of
the Manzone Nervi 2 policy is the end of a job processing by a machine. First of all it is necessary
to verify that in the current buffer there are no jobs that can be worked immediately, so the first
question the current stage has to ask is: “Is there a job in the current buffer that has to be
processed?” (figure 4-17) since if the answer is yes the machine remains in idle state to be ready to
work it, otherwise the current stage has to ask the other stages and the input if they are going to
send it a job. Afterwards the current stage asks: “Are you sending a job j to the current buffer within
arrival time≤TT?”. The logic to follow is the same as in the first policy therefore in this case as well
the counter cont1 at the beginning is reset and counts the jobs that are going to arrive at the current
stage within TT. If the answer is yes, it is necessary to ask another question: “Are you sending a job
j to the current buffer within arrival time ≤ TT + ProcTime?” (figure 4-18). This question aims to
control the following relation (figures 4-14 and 4-15):
76
t* + t** ≤ TT that is equal to t*** ≤ TT
where:
-‐ t* → current job arrival time;

-‐ t** → time between the end of the current job processing and the beginning of the next job
processing;
-‐ t*** → (beginning of the next job processing)-(current job processing time)
The current stage asks each stage this question and whenever the answer is positive the new counter
SumCont is increased by “q” that represents the number of jobs sent to the current stage by the
other stages. The term q is obtained through a process we will explain later according to which the
stage controls its “own table”. SumCont is initialized at zero and at the end of the procedure it will
represent the number of jobs that will arrive within TT + ProcTime.
This logic is implemented till k=S and thus till the current stage finishes questioning all the stages
in the system.
However at this point it is necessary to underline that the counter SumCont also includes cont1 since
SumCont includes all the jobs arriving within a period equal to TT + ProcTime and cont1 instead
includes all the jobs arriving within TT, therefore cont1 is included in SumCont. For this reason we
have introduced the variable cont2 that is the number of jobs arriving in an interval of time between
TT and TT+ProcTime and is calculable as difference between SumCont and cont1. In this way it is
possible to obtain the number of jobs the second energy policy can be applied to.
We can show an example to explain the importance of this passage:
Hypothesising that cont1=3 and cont2=1 the current stage is going to receive 3 jobs within TT and 1
job within TT+ProcTime. This means that a machine in idle energy state shall be available to
receive one of the jobs from the group individuated with cont1 and the job individuated with cont2
because it is not possible to apply any kind of policy if a job is arriving within TT and the next one
between TT and TT+ProcTime. As for the other two jobs individuated with cont1 there will be two
machines in standby with the active timer equal to the arrival time of other jobs arriving after TT+
ProcTime; in fact since there are 2 jobs arriving within TT but not other 2 jobs arriving within
TT+ProcTime there are the conditions to implement the Manzone Nervi 2 policy.
77
If the current stage did not have this information about the arrival times of the jobs these
considerations on the policy implementation would not be possible and the stage only knowing that
4 jobs (SumCont=4 à cont1 + cont2=4 jobs) are arriving but not their arrival times might decide to
keep two machines in idle supposing that 2 jobs are arriving within TT and two jobs within
TT+ProcTime. For this reason it is essential to know not only how many jobs are arriving at the
current stage but also when.
Comparing the value of cont1 and cont2 the possibilities to consider are three. For each of them the
current stage has to check different situations and make different decisions:
-‐ cont1=cont2
-‐ cont1< cont2
-‐ cont1>cont2
cont1=cont2
In this case, as described in figure 4-18, the number of jobs arriving within TT is equal to the
number of jobs arriving between TT and TT+ProcTime, therefore the current stage has to verify if
the machines in idle state are equal to SumCont/2. If the number of the machines in idle is superior
to SumCont/2 it means that in the stage there are all the necessary machines to work the arriving
jobs and Mi will be set to standby.
cont1<cont2
An example for this case, as described in figure 4-19, might be the following: cont1= 2 and cont2=3.
In this situation three machines are necessary to work the arriving jobs: two machines shall remain
in idle to be able to work 4 arriving jobs: 2 within TT and 2 individuated with cont2 arriving within
TT + ProcTime. The last job individuated with cont2 is arriving after TT and will be worked by the
third machine that will be set to standby. The question the stage has to ask it:"M in idle ≥ cont1?", if
the answer is positive the machine I has to be set to standby, otherwise it will remain in idle.
cont1>cont2
To describe the last case cont1>cont2 we can suppose cont1=3 and cont2=2. In this case the current
stage will need two machines in idle to work the two jobs arriving within TT and the two other jobs
arriving within TT + ProcTime since it is not possible to apply the Manzone Nervi 2 policy.
78
Although the first policy condition providing for the job to arrive within TT is complied with, the
second condition providing for the next job to arrive after TT+ProcTime is not satisfied. Thus it is
necessary for the stage to have a number of machines in idle equal or superior to cont2, if not Mi
will remain in idle.
The second energy policy might be applied to the machine that should work the remaining job
identified with the counter cont1 since it complies with the first policy condition. In this situation,
the machine might go in standby till the next job arrives which will enter the stage within a time
superior to TT+ProcTime.
Thus if the number of the machines in idle is inferior to cont2 Mi will remain in idle, if the number
of machines in idle is equal or superior to cont2, the index n will be initialized at 0 and Y= TT +
ProcTime. The index n represents the number of jobs arriving in the current stage after TT +
ProcTime of the current machine, whereas Y represents the moment after which the arriving jobs
are counted that is updated at each iteration. The current stage asks the other stages: Are you
sending a job j to the current buffer within arrival time > Y?”, if the answer is always negative it
means that the jobs individuated as first are the last jobs to enter the system and therefore Mi will
remain in idle to work the last job. Otherwise when the stage k has to send a job to the current stage
it is necessary to know when the first will arrive. This information is essential because when the
machines are put in standby by the stage the timer has to be started with a value equal to the next
job arrival time minus the processing time of the machine taken into account.
To obtain this information the current stage has to ask the stage k when it is going to send the first
job and the answer will be Tk. This value shall be compared with all the values obtained from the
other stages because the current stage has to know when the first job will enter it after TT +
ProcTime in order not to increase the makespan. To compare the Tk value to the values of the other
stages we have decided to introduce a new index for the stages h=k+1. The logic of this new index
is very similar to the one applied to the routing phase in the moment when the machine that finishes
working as first is checked. When the current stage finds a stage which is sending it a job at Tk, the
other stages h=k+1 are checked and the current stage will ask the other stages the question: “Are
you sending a job j to the current buffer within arrival time > TT + ProcTime?”. If the answer is
positive the current stage asks the precise arrival time of this job that will be Th. The current stage
has to compare the two arrival times Tk and Th. If Th>Tk it means that the job of the stage k arrives
as first and the index h will be continuously increased to check the arrival times of the jobs of the
other stages. If Th<Tk it means that there is another stage in the system that is going to send the
79
current stage a job before the stage k, for this reason the index k is updated and increased. The
procedure is restarted from the moment we have defined Y=TT+ProcTime to find the job that
arrives as first.
Once the first job (after TT+ProcTime) arriving at Tk is individuated, the index n is incremented
because the job has been found and the current stage has to verify if the number of machines in
standby with the timer on is equal or superior to the difference between cont1 and cont2 that is to say
equal to the requested machines. In this case Mi is set to standby with the timer on at a time equal to
the lowest time of the timer in the stage. Mi needs to be associated to a timer because should it be
put only in standby, the stage would turn it in idle again when the jobs individuated with cont1
arrive, in this way the system would be “stressed” too much and would consume more energy.
If the number of machines in standby with the timer on is inferior to the difference between cont1
and cont2 it is necessary for the current stage to compare the value of n with the number of
machines in standby with the timer on. This step is essential because it helps avoid the presence of
two machines with the timer on in the current stage for the same job.
If n is inferior to the number of machines with the timer on the current stage updates the value Y
that becomes equal to Tk (in fact if the current stage did not update this value reiterating the process
it would always find the same job), in this way repeating the procedure it will find the “second
fastest job”.
The index n has always to be compared to the number of machines in standby with the timer on at
the end of each iteration until n becomes superior to it. If that is the case it means that the current
stage has individuated the job Mi has to go in standby for with the timer on equal to Tk – ProcTime.
At the end of the procedure we have described, the stage repeats the conceptual model starting from
the routing phase to manage the next job.
Rapuzzi [2] has drawn up a third policy called Current and Next Job and Next Buffer Aware,
CNJNBA, explained in detail in chapter 2.3.3, that can be summarized with the following rules:
1. If the arrival time of Current_job t* ≥ Threshold Time, then go in standby → Plan to switch-on
at: t*-tramp-up (to be idle when the job effectively arrives)
2. If t*** which is defined by the arrival time of Next_job minus the processing time of Current_job
≥Threshold Time, then go in standby
80
→ Plan to switch-on at: t***-tramp-up (to process the two jobs in a row)
3. If there is no place for Current_job in the buffer downstream at the end of its processing time,
then go in standby and postpone its processing
→ Plan to switch-on at: the time when buffer frees one place-tramp-up or TT- tramp-up if it is higher
(minimum required time for the standby to be energetically useful)
4. If there is no place for Next_job in the buffer downstream at the end of its processing time, then
go in standby and postpone the processing of Current_job to group it with Next_job
→ Plan to switch-on at: t****-tramp-up (t**** being defined as the time for the buffer downstream to
free two places minus the processing time of Current_job) or TT- tramp-up if it is higher (minimum
required time for the standby to be energetically useful).
The third energy policy starts from the second policy but also focuses on the system ahead as a
matter of fact before the machine starts working it controls if there is room in the buffer ahead for
the job after its completion. Otherwise the machine will be put in standby and the system will avoid
the blocking.
As already explained at the beginning of the chapter we have decided to oversize the buffer so that
there is always room for the jobs and the procedure is simpler. For this reason it is not possible to
apply CNJNBA to our system.
4.7 Data Collection
These conceptual models have been created to define the logical and physical flows in the system
with the aim of applying energy policies and saving energy. The peculiarity of these models is that
despite their precision they can be generalized. In the practical example carried out with the
simulator it will be shown how the energy policies can be applied to a job shop system with three
stages, two machines and one buffer in each stage and 3,000 jobs to be processed, but thanks to this
peculiarity it is possible to increase the number of stages, machines or jobs to be processed and their
paths without modifying the model.
After having developed the conceptual models of the base case and the energy policies we have
chosen the data to be used during the experiments. First of all we have distinguished between input
81
and output data. The input data are received by the system in input and are fixed or variable
whereas the output data represent the model results and therefore allow to evaluate the system
performances.
The output data depend on the input data of the system, thus this phase is fundamental since it is
possible to draw conclusions about the validity of the energy policies on the basis of the chosen
input data.
We have tried to understand what data are important to our thesis purpose and our experiments and
after individuating them we have analysed their values. As for the processing time of the machines
for example we have established working times for each machine to create a bottleneck stage that
has allowed us to prove the validity of our energy policies.
Besides we have established the level of power necessary during standby, idle, ramp-up and ramp-
down states. We have consulted the existing literature to make these choices and the study
developed by Rapuzzi [2] to decide whether the data shall be fixed or variable. In her thesis the
choice depends on the relevance of the variables and on the simulator: for example the setup times
are considered fixed and equal to zero because they are not considered particularly important for the
energy policies.
The table below shows the data we have used in the simulations classifying them in input/output,
fixed/variable and value.
Input/Output Fixed/Variable Value
Processing time Input Variable

Machine 1

Machine 2

Machine 3

Machine 4

Machine 5
82
Machine 6
Set-up times Input Fixed 0
Working power Input Fixed 8 kW
Idle power Input Fixed 4 kW
Standby power Input Fixed 2 kW
Off power Input Fixed 0 kW
Ramp-up Input Fixed 4 kW

power
Ramp-down Input Fixed 4 kW

power
Ramp-up time Input Fixed 0
Ramp-down Input Variable

time
Buffers Input Fixed 3,000 job

capacity
Jobs arrival Input Fixed 0

rate
Energy Output / /
consumption
Total Input Fixed 3,000 job

throughput
Total makespan Output / /

Table 5: Data collection
The chosen values derive from the comparison with literature and above all from Rapuzzi's thesis.
The table shows the great number of input variables taken into account. Considering them as non
fixed variables it has been possible to study different scenarios and understand in what
circumstances our energy policies are more suitable. Some hypotheses have been made, for
example the jobs transportation in the system has been assumed equal to zero. This hypothesis
which is not very realistic even if also used by Rapuzzi, has been made to simplify the simulation
83
model. The inter arrival times and the processing times that are described in detail in chapter 6 have
been modified during each experiment to analyse the various results obtained.
4.7.1 Model Software Implementation
After defining the conceptual model and identifying all the model variables we have used the
Tecnomatix-Plant Simulation version 12 simulator.
First we have studied the simulator to understand how to transfer the concepts and the logical and
physical flows of the above mentioned models into such a complex program.
Once created the layout we have learnt how to write the code so that the machines could behave
exactly as provided for in the conceptual models.
We have simulated the base case, the Manzone Nervi 1 policy and Manzone Nervi 2 policy
modifying the different variables every time.
Below is the simulator screen that describes the layout:
Figure 4–21: Simulator main screen
As shown in the figure we have created a job shop production system where there are three stages,
each of them with two machines and one buffer. This has been possible using the elements available
in the simulator toolbar. The jobs enter the system from the input ("Source" at the bottom on the
left), they visit the stages according to their paths and when they are completed they go out through
the output ("Drain" at the bottom on the right). The 27 connectors allow the job to reach all the
stages: from the input it can go to the stage A, B or C according to the operation it has to undergo
84
first. After arriving in the buffer of the stage it can be worked by one of the two machines after the
energy evaluations carried out by the stage itself. The connectors after each machines allow the job
to visit the next stage or to go out from the system. At the top on the right there are two tables called
TableFile and Sequenza. The TableFile shows the job arrival sequence from the input, we have
decided to work 3,000 jobs in the same sequence for each carried out experiment. The Sequenza
table defines the different paths of the single jobs. In our case we have established that the Entity1
visits the stages with sequence A-B-C, Entity2 with sequence B-C-A, Entity3 with sequence C-B-
A, Entity4 with sequence A-C-B, Entity5 with sequence B-A-C and Entity 6 with sequence C-A-B.
The other two objects at the top on the right are the Chart and the Chart1. The graphics below allow
to evaluate the state of the machines and their energy consumption during the simulation runs. The
Chart is relative to Resource Statistics and shows the state of the machines during simulation. The
Chart1 instead shows the percentage of energy consumed in the same period. Taking into account
the machine 1 it is possible to observe that during the simulation 80% of the consumed energy has
been used to work and 20% has been wasted to keep the machine in idle.
Figure 4–22: Resource statistics chart
85
Figure 4–23: Energy statistics chart

We have written different codes in every stage called Methods to carry out the simulations:
-‐ Job_shop: in a job shop system the jobs do not visit the stages with the same order but each
typology has its own path which is indicated in the Sequenza table. We have written a
Method in the simulator to be sure that the stage reads correctly the table after a job inside it
has been worked and goes to the next stage. This type of Method is present both in the base
case and in the cases where the energy policies are applied;
-‐ Buffer_exit: this Method, the routing phase, represents the main innovation of our model
compared to the already existing policies. When a job in the buffer is the next one to be
worked the stage has to choose the machine that will process it according to the energy state
of all the machines in the stage.
-‐ Go_standby: according to the Manzone Nervi 1 policy soon after job completion if the
buffer is empty the stage asks the other stages if they are sending it a job within TT, whereas
according to the Manzone Nervi 2 policy other considerations have to be made as we
describe in detail when we explain the conceptual models. The machine taken into account
is set to standby or not depending on the answer, in fact this Method allows the machines to
86
go from idle to standby state. This Method is applied to the cases in which the energy
policies can be implemented;
-‐ Go_idle: this Method as well is applied to the cases in which the energy policies can be
implemented. It is read during the routing phase when the stage decides on the machine the
job has to be assigned to and decides that a machine has to go in idle state, in fact this
Method allows the machines to go from standby to idle state.

Figure 4–24: Buffer_exit Method example
Considering each single machine we have to decide on the processing and power variables. We are
going to include some screens to show how it is possible to set some variables in the simulator.
The screen below shows where we have set the processing times. As already said to simplify the
model we have set the setup time equal to zero and we do not consider the possibility of failures.
87

Figure 4–25: Machine 1 parameters in Tecnomatix Plant Simulation
The following screen shows where we have set all the energies. As for the ramp-up and ramp-down
phases it is not possible to set the consumed energy but only the time required by the machine to go
from idle to standby state and vice versa as well as the respective necessary power.

Figure 4–26: Machine 1 parameters in Tecnomatix Plant Simulation
88
As for the system input we have written a Method that makes it possible, once a job arrives, to read
the table called TableFile that describes all the different jobs paths. According to the typology of the
job the Method allows the input to send it to the right stage that shall carry out the first operation.
As shown in the screen below it has been necessary to make two decisions regarding the input
activity:
-‐ Interval: it is the job arrival time, here the inter arrival time of the jobs in the system is
written. The decisions on these times have been essential to the results of our work and are
described in detail in Chapter 6;
-‐ Mu selection: it is possible to introduce the jobs in the system in different ways, in fact the
sequence can be random, cyclical or fixed. Using a random sequence, once defined the
number of different jobs the simulator introduces them in the system at random at each
simulation run. Using a cyclical sequence a determined sequence is repeated more times for
a defined period, using a fixed sequence a sequence is created that does not change during
all the experiments.
We have chosen to use the fixed sequence and we have used the same sequence for both the base
case and the cases where the energy policies are applied comparing them only from the energy
consumption and makespan point of view. If we had considered the random sequence the
comparison would not have been so precise.

Figure 4–27: Input parameters in Tecnomatix Plant Simulation

89
The image below (figure 4-28) represents Tecnomatix’s screen with the results of a simulation run.
At the top the simulation time is shown, here equal to 10 hours.
The table shows information relative to the simulation. The column Object refers to the station
where the jobs are at the end of the experiment, that is the output (called Drain by the simulator).
The column Mean life time indicates the time required to complete the corresponding job. The
columns three and four refer to the Throughput and the Throughput per hour, in our case the
throughput is invariable in all the experiments being the sequence fixed. The percentages shown in
the columns Production and Storage represent the time the jobs remain in the machine and in the
buffer. Finally the percentage in the column Value added, equal to the Production values, refers to
the time necessary to obtain the value added.

Figure 4–28: Simulator results screen

90
5. SIMULATION FRAMEWORK

5.1 Simulation

The manufacturing companies are important centres within a more complex network. They are
characterized by high complexity, several interrelations among the different processes, internal and
external events and the variability of the processes influencing effectiveness in case of urgent orders
or failures in the work centres.
This is why it is important to be able to create optimized production plans and verify their execution
in advance to utilize the assets and the resources at best. Being able to control the variability of a
process is the key to minimize costs.
Thanks to planning, optimisation and the simulation tools we can anticipate the variability and
achieve continuous improvements, obtaining the maximum investment performance. These tools
allow to solve complex situations and thus make critical decisions in less time.
The key words are factory, plans and production processes simulation and optimization in real time.
First of all it is necessary to make a distinction as for the simulation utilization in manufacturing. As
a matter of fact it can be used for two reasons:
- manufacturing system design: when a factory is being planned ex novo and therefore all the
decisions are still to be made, including tooling strategy, material-handling systems, system
size, process flow configuration, flexibility needed for future engineering changes or
capacity adjustment, and space strategy [51]. Simulation has been often used as a support
tool for those decisions that have a strong impact on the system in the long term; actually
modifying them is difficult and expensive. For this reason the utilization of this tool in this
phase is very useful since it is possible to simulate different configurations to choose the
best one according to the targets being set;
- manufacturing system optimisation: this is the case analysed in this work where there is a
factory and some performances are to be improved. With simulation it is possible to
experiment different situations and logics of system to individuate the best solution
according to the target which has been set.
91
It is important to include sustainability and energy efficiency indicators in these simulation models,
whatever the goal. For example Heilala and other researchers proposed a simulation tool called
Simter for the designing phase that helps maximize production efficiency considering the
environmental impact [52]. The figure below shows the scheme of their model.

Figure 0–1: Hybrid combination of DES and analytic calculation [52]
The advantages deriving from the use of the simulation technique are several:
- cost reduction: if experiments were carried out directly on the real system they would be
very expensive. Using simulation it is possible to estimate the economic consequences
linked to the hypothesized management choices beforehand; in this way we are able to
individuate mistakes before they are made and avoid costs due to wrong choices;
- better understanding of the phenomenon: since it is possible to repeat experiments more than
once, even with different input data, it is possible to understand the phenomenon being
analysed deeply. Besides the possibility of repeating the experiments allows to have more
time to collect data;
- time reduction: the simulation allows to carry out experiments in a short time, whereas
carrying out experiments on a real system may take long;
- risks reduction for the most innovative ideas: simulation makes it possible to carry out
innovations at low risk which would not be experimented out of fear of failure.
Therefore the aim of simulation is to create the dynamics of the real system in a controlled
environment to be able to analyse them at best.
Nevertheless we should not forget the disadvantages of simulation:
- simulation results can give only an indication of what the system behaviour will be;
- the model development might be expensive;
- the simulation output must be interpreted and analysed to identify the best solution.
Shortly we can say that carrying out a simulation has a cost as for human resources, equipment and
92
efforts. Simulation is not able to guarantee the best solution of a problem but it is a valid tool that
gives precious indications to make choices with knowledge of the facts.
Besides the more technical problems linked to the model calculation, time is being reduced sensibly
thanks to the development of commercial simulators which are easier and easier to use.
Simulation is one of the possible modelling techniques that a decision maker can use during the
decision-making process. The proposals can be evaluated with the simulation tool thus guaranteeing
analysis capability both at local level, considering the part of the plant being taken into account, and
at systematic level, thus considering the effects between the operations and the system resources
[53].
Before dealing with the simulation concept it is necessary to explain the meaning of model, a
concept strictly bound to the first one. In the text “Modellazione dei sistemi produttivi” by Marco
Macchi and Sergio Terzi [54], a model can be defined as “the simplified representation of
“something”, where this generic something corresponds to a determined system and behaviours
being observed in it”.
According to the authors the link between modelling and simulation can be explained introducing
the following definition of simulation: “a numerical technique founded on the rules of the scientific
model and on the theory of the system and relative modelling, used to carry out experiments on a
computer (or manually as well), suitable to reproduce the functioning of a system over the time”
[55].
Therefore considering the above mentioned text we can say that simulating means emulating the
behaviour of a system reproducing the existing interactions among the system elements, allowing to
understand its behaviour in advance and how it can change if some factors vary. The simulation
models represent a whole set of logical and mathematical relations that describe the system
components and their relationships.
There are different types of simulation models:
- static models vs dynamic models: a static model represents a system in a determined instant
of time or generally a system where the time variable has no influence such as in the Monte
Carlo simulation; on the contrary a dynamic model allows to represent a system in its
evolution in time which can be necessary during the study of a transport system;
- deterministic models versus stochastic models: deterministic models contain no
“probabilistic” elements. This means that once the input values are attributed the output is
univocally determined as for example in a chemical reaction. In stochastic models instead
the input models or the occurrence probabilities of events are not univocally determined but
93
they vary according to the statistical distributions. Therefore these simulation models can be
used to determine the utilization level of tool machines in a production stage;
- discrete models versus continuous models: this is a distinction within dynamic models; in
the first ones the evolution of systems is represented where the state variation is supposed to
occur instantly, in particular instants of time. A production stage is usually modelled as a
discrete system because the variables change in precise instants. In the continuous models
instead the evolution of systems is represented where the state variation occurs steadily with
regard to the time variable, for example when it is necessary to study the temperature
variation of a flow that is cooling. The system undergoes a change of state when an event
occurs, remaining in the same state in the period between two events, whereas in the second
ones the system state changes continuously;
- real time models versus scaled time models à a simulation in real time is used when the
programme must interface with a component, a simulation in scaled time is used to carry
out a quantitative analysis of a system behaviour in which we want to verify different
situations as fast as possible.
This work deals with the study of a job shop production system and therefore provides for the
creation of dynamic (where time is a variable), deterministic and discrete models (where events
occur in different instants of time and in scaled time).
Simulation can be used in many different areas, in the military and civil field as well as in sciences
such as chemistry or physics, in video games and can have different uses depending on targets and
interests area.
This thesis focuses on the utilization of simulation in industrial and business sectors and its main
objectives are the following:
- new systems planning: simulation allows to compare the performances of different
solutions;
- modification of existing systems: with simulation it is possible to obtain information on the
variables modification real impact;
- managing: simulation allows to estimate the efficiency of different managing policies.
For a better understanding of simulation, taking into account the definitions given in the text
mentioned at the beginning of the chapter, it is necessary to introduce new logical elements:
entities, resources, states, events and activities.
The entity is the independent element able to move within a system to which the system
performance itself is linked. These objects are temporary and undergo passive transformations; in
94
our case it is the job that must be manufactured by the machine (resource). The resources are the
system active elements that consume simulation time. The queue instead is a passive element, it
does not consume simulation time and carries out the only activity of storage and parking.
Resources and entities are described by the state in which they remain for a certain lapse of time
(for example the machine can be in idle or in working state). The switching from a state to the other
is the result of an event which is caused by the beginning or end of an activity. The event is the
point where the state of an element of the model changes, changing the system behaviour and
causing consequent activities (for example a machine starting to work that was in idle before).
There are two types of events: bound and conditional events. A bound event is an event that occurs
certainly as a consequence of another event. A conditional event only occurs if specific
requirements are met.
Each of these elements can be described through attributes, also called permanent variables that is
they do not change in the course of time. The permanent variables of an entity can be dimension,
weight and name; those of a resource can be set up time and business logic (LIFO, FIFO etc.).
There are as well variables defined as temporary, or state variables, that are numerical or logical
variables immediately characterising a size and thus changing over time.
5.2 Simulation Project
Simulation is based on an iterative process composed of four fundamental steps [56]:

-‐ problem knowledge;
-‐ conceptual model;
-‐ coding of the model and software;
-‐ attainment of a solution and/or understanding of the system.
Repeating the process more times and sometimes carrying out movements backwards it is possible
to pass from a good solution to a better one.
95
Figure 0–2: Simulation of an iterative process [1]
The study of a system through simulation is a rather long and complex process where more
components often interact. It is therefore important to apply a work method able to organize the
different phases. There are of course different methods to plan a simulation project, we will refer to
the one shown by Macchi and Terzi in their text “Modellazione dei Sistemi Produttivi” [54].
Figure 0-3: Simulation phases [54]
96
As shown in the framework the first step is the clear identification of the model objective, defining
the performance measures of the system to be analysed and the simulation horizon. In this way it is
possible to focus on a part of the process obtaining a more precise and useful simulation.
The objectives may be different:
-‐ performance analysis: relative to the use of resources and system output;
-‐ capability analysis: verifying that the used resources are exploited in the right way;
-‐ configurations comparison: individuating the best configuration in relation to a determined
function set as an objective;
-‐ optimization: finding the best solution among the proposed ones;
-‐ sensitivity analysis: individuating the variables having more impact on the system;
-‐ visualization: creating the solution of a reality which is “visible”, even if it might not exist
yet.
It is necessary to decide how detailed the representation of the system components, their functional
relations and the boundary conditions shall be. The choice must be coherent with the available data
and depends on:
-‐ project objectives: if the objective is punctual the system shall be modelled and then
simulated precisely, otherwise the analysis may be less accurate;
-‐ performance measures;
-‐ data availability;
-‐ time constraints;
-‐ economic constraints.
Once the objectives have been defined it is important to define a working plan, the foreseen time
and efforts.
At this point the conceptual model is individuated with the system logical element to be simulated
and at the same time the structural and model input data are collected.
Collecting data relative to the system to be represented is a long and expensive phase in modelling
but it is indispensable to obtain an efficient model. For this phase it is necessary to individuate and
define the components to be included in the system and their functional relations, then define all the
subsystems belonging to the system being analysed and the relative “boundary conditions” as well
as individuate the variables and the parameters associated with the components.
97
At this point, before implementing the software model it is necessary for the conceptual model we
have drawn up to be valid.
Figure 0–4: Process for the conceptual models validity
After confirming the validity of the conceptual model it is possible to implement the software
model choosing and using a programming language for the definition of the software model of the
system to be simulated.
Once the software model has been created the phases of checking and validation shall start. The
model check implies the control of the formal correctness of the implemented software model
obtained through the simulation language with debugging tools. During the validation phase it is
verified that the simulation model is coherent with the system being analysed from a conceptual
point of view. It has to be underlined that there is no simulation model of a real system which is
absolutely valid, but the validation is in accordance to the study objectives and besides the checking
and validation phases shall not be carried out at the end of the model development but constantly
during all the phases. There are different techniques to verify the models, below we mention some
of them:
-‐ building of the simulation model for independent sub-models;
-‐ sensitivity analysis;
-‐ simulation of known cases for the comparison;
-‐ check of the event list;
-‐ use of graphic animation.
The most used techniques for the validation are:
-‐ experts' judgement;
-‐ managers' involvement;
-‐ comparison with the real system:
98
o trace driven simulation;
o paried t-test;
o confidence interval;
-‐ if no data from the real system are available:
o sensitivity analysis, DOE.
After evaluating the model consistency and completeness the experiments are carried out through
the simulator, it is necessary to define the number of runs and for each experiment its duration, the
variables etc. Proceeding with a series of tests and statistical analyses it is possible to analyse the
output data, compare and interpret them. This phase usually ends with a final report where the
benefits and the limits of experimentation are identified.
5.3 Simulator Choice
The choice of the simulator to work with has been a very important phase. The software choice has
to be strongly bound to the specific use requirements, therefore to the objective to be reached.
The most important characteristics to evaluate according to the text “Modellazione dei sistemi
produttivi” by Marco Macchi and Sergio Terzi [1] are the following:
-‐ modelling flexibility: considered as capability to conform to the infinite system varieties;
-‐ execution velocity: elaboration time and time necessary to achieve results;
-‐ compatibility: the software compatibility with the operative systems;
-‐ animation: it refers to the dynamic observation of the model that however may slow down
the simulation execution;
-‐ statistical capabilities: it refers to the presence of models able to carry out statistical data
analyses;
-‐ results report: it refers to the possibility of having both standard reports relative to statistics
on performances and personalized reports;
-‐ customer service: availability of texts, examples of solved problems etc.;
-‐ cost: element not to be underestimated above all as for use requirements.
Many different types of software have been individuated that could be suitable to our requirements.
Starting from the list proposed by Federica Vaccari [46] and then reconsidered by Nicole Rapuzzi
[2] before starting this work we have updated the release.
99
Below we submit the three lists (table 6, table 7, table 8) with relevant release evolutions.
Software name Producer Release

Tecnomatix Plant Simulation Siemens 10.1 (2012)
Arena Rocwell Automation 14 (2012)
Anylogic XJ Technologies 6.6 (2011)
Simul8 Simul8 Corporation SImul8 2010 (2010)
Automod Applied Materials 12.3
Delmia Dessault Systèmes V6 (2013)
ProModel ProModel, Inc. 7.5 (2010)
Witness Lanner 12 (2012)
Flexsim Flexsim Software Product, Inc. 6.0.2 (2012)
Entend Sim Imagine That, Inc. 8.0.2 (2011)
GoldSim GoldSim Technology Group LLC GoldSim Version 10.5 (2011)
Renque RND Technology Consultants 3.15.015 (2012)
SimEvents MathWorks 2012
Table 6: Simulator release list. Update 2013 [46]

Tecnomatix Plant Simulation Siemens 12 (2014)
Arena Rocwell Automation 14.7 (2014)
Anylogic XJ Technologies 7 (2014)
Automod Applied Materials 12.3
Delmia Dessault Systèmes V5-6 (2014)
ProModel ProModel, Inc. 9.2.3 (2014)
Flexsim Flexsim Software Product, Inc. 7 (2013)
Entend Sim Imagine That, Inc. 9 (2013)
GoldSim GoldSim Technology Group LLC 11.1.2 (2014)
Renque RND Technology Consultants 3.7 (2014)
SimEvents MathWorks 4.3.3 (2014)
Table 7: Simulator release list. Update 2015 [2]
100
Tecnomatix Plant Simulation Siemens 12.0.3 (2014)
Arena Rocwell Automation 14.7 (2014)
Anylogic XJ Technologies 7 (2014)
Automod Apllied Materials 12.6.1
Delmia Dessault Systèmes V5-6 (2014)
ProModel ProModel, Inc. 9.2.3 (2014)
Flexsim Flexsim Software Product, Inc. 7.7 (2015)
Entend Sim Imagine That, Inc. 9.2 (2013)
GoldSim GoldSim Technology Group LLC 11.1.5 (2014)
Renque RND Technology Consultants 3.7 (2014)
SimEvents MathWorks R2016a
Table 8: Simulator release list. Update 2016
The choice of the simulator has been made taking three fundamental criteria into account:
-‐ level of adoption: it means the number of researchers using the simulator. This first criterion
has been one of the most important; as a matter of fact a high level of adoption by other
researchers who have been working on these issues testify that the simulator has the right
functionalities and tools for the work to be carried out;
-‐ rapidity of experiments execution: this characteristic is very important since a lot of
simulation runs have been necessary to analyse and prove our policies;
-‐ the possibility of setting the machine powers and energy states since for this work they are
fundamental input data;
-‐ the possibility of having a licence through Politecnico di Milano to work on the simulator.
For these reasons we have decided to work with Tecnomatix-Plant simulation, version 12. This tool
allows to take the energy variables and the machines energy states into consideration, evaluating the
variables within the processes and the production rhythms with a high level of precision.
101
6. EXPERIMENTS AND RESULTS
ANALYSIS
6.1 Design of Experiments

In this chapter we want to describe all the experiments we have carried out to verify that the
decisions we have made to adapt the CJA and CNJA policies to the job shop actually lead to energy
savings and are therefore cost effective.
In this important phase we have followed the conceptual models we have described in chapter 4
step by step and using the Tecnomatix-Plant Simulation simulator we have been able to prove the
energy savings deriving from our decisions.
Before carrying out the simulation runs it has been necessary to identify the variables used in the
experiments, this being an essential phase since the aim of the experiments is to understand the
performance variations in output as a consequence of the variables variations in input.
The variables cannot be considered in the same way; as a matter of fact according to Macchi and
Terzi’s classification [1] they can be decision variables, controllable factors, non-controllable
factors and performance variables.
-‐ Decision variables: these are “independent variables” that represent the model input. They
are the decisional tools for the model user, the levers used to enhance the performances. In
this work, they are represented by the two different energy policies;  
-‐ Controllable factors: these are hexogen independent variables that characterise the system.
They are fixed and deterministic parameters. In this work the parameters such as the
processing time of the machines, the system layout, the transportation times on buffers and
the power profile of machines have been considered as controllable factors. To simplify the
model we have included the job arrival time in the system in this category;
-‐ Non-controllable factors: these are hexogen independent variables, like the controllable
factors, but they are stochastic and not deterministic. We have not included them in our
work;
-‐ Performance variables: these are the dependent variables of the simulated system, made up
of all the parameters used as a performance index, through which the system is evaluated
102
and alternative decisions are made.  
The variables affect the model determining different outputs that can be expressed by the following
formula:
𝑌 = 𝑓 𝑋, 𝑧 + 𝜀
Generally speaking the model performance is a function of decisional variables and controllable
factors and is affected by hexogen elements that are not directly controllable. The figure below
(figure 6-1) summarizes what we have just explained:
Figure 0–1: Variables making up a model [1]

In chapter 4 we have indicated the input and output data used during simulation. We want now
classify them according to Macchi and Terzi’s classification [1].
Decision Controllable Non controllable Performance

variables factors factors variables
Energy saving
X
policy
Processing time X
Set-up times X
103
Working power
X
Idle power
X
Standby power
X
Off power
X
Ramp-up power
X
Ramp-down power
X
Ramp-up time
X
Ramp-down time
X
Buffers capacity
X
Jobs arrival time

X
Threshold time X
Transportation
X
times
Energy
consumption X
Total throughput
X
Total makespan
X
Table 9: Macchi and Terzi’s variables classification [1]

We have considered each variable in a different way, some of them have been studied more in
detail and during the simulation runs we have attributed them different numerical values to better
understand the system behaviour. Other variables on the contrary have been considered less
important to verify the energy savings deriving from our policies.
These variables are:
-‐ energy saving: this is the fundamental decision variable of our thesis. The main idea of our
model is to reduce the total energy consumption in a job shop system. Focusing on the
application of specific energy policies during the simulations we have not taken into account
104
all the components of the total energy but we have only focused on those components that
can be differential and we have compared them case by case. The energy policies refer to
the energy saving obtained from the variation of the energy state of the machines in the
system; in fact they are set to standby or kept in idle state according to the needs. We have
considered the components linked to idle power, standby power, ramp-up and ramp-down
power;
-‐ processing time: we have established deterministic values for the job processing. The
machines are set with the same processing time for every job they have to work. In each
stage the machines are identical but they are different from stage to stage. As for the
processing time of the machines we have established working times for each machine to
create a bottleneck stage that has allowed us to describe and prove the validity of our energy
policies and consequently the energy savings;
-‐ setup times: to simplify the model the setup times have been considered equal to zero;
-‐ ramp-up/ramp-down power and ramp-up/ramp-down times: in our energy policies the stage,
after a machine finishes working, decides whether it has to be set to standby state or not, but
in that moment does not decide when the machine has to be switched on.
When a job arrives in the buffer, the stage has to find the proper machine that can process it
and if necessary the stage will decide to switch the machine from standby to idle state.
For this reason if the stage switches the machine from standby to idle state theoretically the
job should wait for a ramp-up time, otherwise to prevent it the stage might program the
machine switching on from the very beginning. Actually since the job shop system is a very
complex system where there are a lot of directional flows if we program when to switch the
machine from standby to idle state it may happen that the machine switches on at a time t
but that at that time there is no job for it to work because the job has been given to another
machine which has switched on simultaneously.
Considering the sum of ramp-up and ramp-down equal to the threshold time and since the
job should wait for the ramp-up time, for practical reasons we have considered the ramp-
down time equal to the threshold time and ramp-up equal to zero. In this way the makespan
does not increase;
-‐ buffers capacity: since we are in a job shop system if we considered a very limited capacity
of the buffers we would risk the blocking of the system because should all the buffers be full
the machines would not know where to send the jobs after completion. For this reason since
the capacity of the buffers is not essential to our work, the buffers in our system have been
oversized;
105
-‐ transportation: this aspect as well is not essential to our aim therefore we have considered it
equal to 0;
-‐ threshold time (TT): once a machine finishes working the stage decides about its energy
state according to the threshold time. In our work we have hypothesised it equal to the time
necessary to allow the machine to switch from standby to idle state;
-‐ inter arrival time (IAT): inter arrival time of the jobs in the system. The input sends the jobs
to the system at different times according to the various experiments. In the successive
paragraph we indicate the precise values of this variable;
-‐ total throughput: in our work the throughput is fixed and therefore it is a controllable
deterministic variable. We always consider the production of 6 different typologies of jobs
repeated in random sequence composed of 3,000 jobs. Each job is characterized by a
different path inside the system and the random sequence is the same for each run so that it
is possible to compare all the experiments.
As for the output variables we consider energy consumption and total makespan because we want to
verify if after the energy policies and the established input values the energy consumed is inferior to
the base case where the energy policies are not applied.
It is important to underline that some abbreviations are used in our work such as :
-‐ IAT: inter arrival time;

-‐ TT: threshold time;
-‐ BC: base case;
-‐ MN 1: the Manzone Nervi 1 policy;
-‐ MN 2: the Manzone Nervi 2 policy.
We have elaborated two energy policies called the Manzone Nervi 1 policy and the Manzone Nervi
2 policy on the basis of the analysis of the literature and the production context we want to give our
contribution to.
As widely described before, the aim of these two policies is to reduce energy consumption during
the production of a precise production mix not increasing the makespan; as a matter of fact during
the several experiments we have carried out we have reported huge energy savings and only a
minimum increase of the makespan inferior or equal to 0.05% compared to the base case. This
makespan increase occurs when the energy policy is applied to the last job in the last machine; in
106
fact the increase is maximum equal to the threshold time because the last job to be worked waits for
maximum an interval equal to TT. If the energy policy is applied before the processing of all the
other jobs it does not affect the total makespan but only their position in the system; in fact if before
the processing of any other job the machine is set to standby allowing the implementation of the
energy policy the job will wait in the buffer of the machine in standby longer than in the next
buffer.
Table 10 shows an example where the difference of makespan between the cases where the policies
are applied and the base case is irrelevant. The processing times of the machines is 30 seconds in
the stage A, 1 minute and 30 seconds in the stage B and 2 minutes and 30 seconds in the stage C.
Other examples are reported in annex 1.
Makespan Makespan Makespan

TT IAT BC MN 1 MN 2 △ MN1-BC △ MN2-BC
00:01:00 00:00:00 112:34:30 112:34:30 112:34:30 0.00% 0.00%
00:01:00 00:00:30 112:34:30 112:34:30 112:34:30 0.00% 0.00%
00:01:00 00:01:00 112:35:00 112:35:00 112:35:00 0.00% 0.00%
00:01:00 00:01:30 112:35:00 112:35:00 112:35:00 0.00% 0.00%
00:01:00 00:02:00 112:36:00 112:36:00 112:36:00 0.00% 0.00%
00:01:00 00:02:30 125:06:30 125:07:00 125:07:00 0.01% 0.01%
00:01:00 00:03:00 150:06:30 150:07:30 150:07:00 0.01% 0.01%
00:01:00 00:03:30 175:06:30 175:06:30 175:06:30 0.00% 0.00%
00:01:00 00:04:00 200:06:30 200:06:30 200:06:30 0.00% 0.00%
Table 10: Difference of makespan among base case, the Manzone Nervi 1 policy and the Manzone Nervi 2 policy
The energy consumption we consider in our examples includes working energy, standby energy and
energy consumed during idle times, it is exactly this last energy we aim to minimize during
107
production. Both our policies are made up of two phases:
-‐ routing phase;

-‐ decisional phase on a machine energy state.
The routing phase is the same in both policies and represents the most innovative aspect of our
work. It is a phase in which the stage chooses what machine the job in the buffer is to be assigned to
on the basis of its energy state.
When a job is in the buffer and has to be worked by a machine, the stage analyses the energy state
of the machines in that moment and decides what machine can process the job. The decision is
made on the basis of a priority classification according to which the stage first controls if there are
machines in idle, then in working state with a remaining processing time inferior to the threshold
time and finally machines in standby that can be set to idle state.
The decisional phase on a machine energy state regards the choice the stage makes when a machine
finishes working, thus the stage decides if the machine has to remain in idle ready to work another
job or it has to be set to standby. The considerations the stage makes are different in each policy; in
fact according to the Manzone Nervi 1 policy a machine after working has to be set to standby if it
is not going to receive a job within the threshold time so that it does not remain in idle state thus
saving energy and consequently saving money.
Figure 0–2: Representation of the Manzone Nervi 1 policy
108
Where:
-‐ Mis represents the machine i of the stage s;
-‐ (X1,i)s represents the job 1 processed in the machine i of the stage s;
-‐ (X2,i)s represents the job 2 processed in the machine i of the stage s.
With the Manzone Nervi 2 policy a machine after working has to be set to standby on the basis of
the two next jobs’ arrival time, thus the machine can be set to standby state even if the first job
arrives within TT (this cannot happen using the first policy) and the second job arrives after a time
calculated as the sum of t* and t**, where t* is the interval between the moment the machine
finishes working and the moment the first job arrives and t** is the interval between the moment
the machine finishes working the first job and the moment the second job arrives.
Figures 6-3 and 6-4 explain how we want to modify the base case to obtain energy savings with the
Manzone Nervi 2 policy.
109
Where:
-‐ Mis represents the machine i of the stage s;
-‐ (X1,i)s represents the job 1 processed in the machine i of the stage s;
-‐ (X2,i)s represents the job 2 processed in the machine i of the stage s.
It has been necessary to carry out a lot of simulation runs to prove the validity of our energy
policies and consequently understand the trends of energy savings when the input variables change.
First we have defined a job shop production system composed of three stages, each of them having
a buffer and identical machines. Figures 6-5 and 6-6 represent the system and a generic stage
respectively.
Figure 0–5: Representation of the information flow in the system
110
Figure 0–6: Representation of a generic stage
Later we have defined the production mix to be considered in each experiment and have
hypothesised 6 different typologies of jobs distributed at random in a sequence of 3,000 jobs. In
each experiment the random sequence is the same.
Table 11 shows the jobs produced by our system: they are called Entity1, Entity2, Entity3, Entity4,
Entity5 and Entity6. Their sequence of visit to the stages is described, for example Entity 1 first
visits stage A, then stage B and finally stage C.
JOB STAGES
Entity1 A B C
Entity2 B C A
Entity3 C B A
Entity4 A C B
Entity5 B A C
Entity6 C A B
Table 11: Sequence of visit to the stages
After choosing the jobs to be worked and their sequence we have carried out the analysis of the
variables affecting the system and we are going to describe the design of experiments with the
relevant results in detail.
We deem that to better study our system it is essential to modify three variables for each
experiment:
111
-‐ inter arrival time (IAT): inter arrival time of each single job in the system. While simulating
we have assumed different situations, that is the jobs entering all together at the instant zero
or one by one as shown in table 12;
-‐ processing time (ProcTime): time necessary for the machines to work the jobs. We have
varied the processing times considering both totally balanced cases and non-balanced ones;
-‐ threshold time (TT): time necessary for the machines to switch from idle to standby state
and vice versa. The experiments have been carried out assuming TT equal to the values
shown in table 12 below. We have defined 𝑇𝑇 = 𝑡?Gc>B> + 𝑡?Gc>A@eF after a series of
calculations and evaluations as described in chapter 4.
We have then defined all the values to attribute to the variables and a design of experiment as
resumed in table 12 below. We are going to show how these values have been combined and what
results have been achieved, nevertheless only a few examples will be given in this chapter, all the
others being shown in annex 1.
Threshold time Inter arrival time Processing time of the machines in the stages
Stage A Stage B Stage C
00:00:30 00:00:00 00:01:30 00:01:30 00:01:30
00:01:00 00:00:30 00:00:30 00:01:30 00:02:30
00:01:30 00:01:00 00:00:30 00:01:30 00:04:30
00:02:00 00:01:30 00:01:40 00:02:20 00:03:10
00:03:00 00:02:00
00:04:30 00:02:30
00:05:00 00:03:00
00:06:00 00:03:30
00:08:00 00:04:00
00:12:00 00:05:00
Table 12: Design of experiments
Before explaining all the experiments in detail we want to underline that we always work on energy
consumptions to minimize them. The energy the system consumes is made of working energy and
112
idle energy. Applying our policies we aim to transform idle energy into a combination of idle and
standby energy consuming less energy in total and not varying the makespan compared to the base
case.
As figure 6-7 shows, considering one of the experiments we have carried out, in the base case the
machines remain in idle state for a time equal to 50% of the simulation time. Applying the first
energy policy the energy wasted during the idle state is decreased by 90% and applying the second
policy we can obtain a decrease by 95% compared to the base case. Obviously as for the working
energy it is not possible to reduce it since we want to produce the same number of jobs in the same
period of time.
In figure 6-7 we have contemplated the case where the machines of stage A, B and C have a
processing time equal to 15 minutes, 1 minute and 30 seconds and 2 minutes and 30 seconds
respectively.
Figure 0–7: Ttime percentage in the different energy states in the base case, the Manzone Nervi 1 policy and the
Manzone Nervi 2 policy: ProcTime=(00:00:30-00:01:30-00:02:30); IAT=00:02:30
6.2 Routing Phase Effects

In this paragraph we want to highlight the effects of the first phase of the Manzone Nervi 1 policy,
that is the routing phase taking place whenever the job is in the buffer and has to be sent to a
113
machine to be worked; the stage analyses the energy state of the machines in that moment and
decides what machine can process the job. This phase represents an innovation in literature and in
table 13 we indicate the percentage difference of energy savings obtained applying the Manzone
Nervi 1 policy compared to the Manzone Nervi 1 policy without the routing phase. The energy
saving in both cases is calculated compared to the base case.
Table 13 shows the variables value combinations in this example: in the columns indicate the
threshold time, the inter arrival rate, the processing time of the machines in the stages and the
results of the experiments (in this case the energy saving of the Manzone Nervi 1 policy compared
to the base case and the energy saving of the Manzone Nervi 1 policy without the routing phase
compared to the base case). Each row represents one experiment with all the values of the variables
and the relative results. This structure of the table is the same as the one of the other tables shown in
this thesis.
∆Energy ∆Energy
Threshold Inter Processing time of the machines in the saving MN saving MN
time arrival stages 1-BC 1 NO
time ROUTING-
BC
00:01:00 00:00:00 00:00:30 00:01:30 00:02:30 38.63% 32.47%
00:01:00 00:00:30 00:00:30 00:01:30 00:02:30 39.05% 32.27%
00:01:00 00:01:00 00:00:30 00:01:30 00:02:30 39.52% 32.37%
00:01:00 00:01:30 00:00:30 00:01:30 00:02:30 38.65% 32.09%
00:01:00 00:02:00 00:00:30 00:01:30 00:02:30 41.87% 36.51%
00:01:00 00:02:30 00:00:30 00:01:30 00:02:30 41.94% 39.38%
00:01:00 00:03:00 00:00:30 00:01:30 00:02:30 45.53% 44.11%
00:01:00 00:03:30 00:00:30 00:01:30 00:02:30 46.33% 44.81%
00:01:00 00:04:00 00:00:30 00:01:30 00:02:30 48.21% 47.63%
00:01:00 00:04:30 00:00:30 00:01:30 00:02:30 49.99% 49.99%
Table 13: Variables value combinations used in figure 6-8 and routing phase effects
On the top of figure 6-8 the combination of the processing time of the machines in the stages and
the threshold time we have used for the specific experiment is written. For example here the
processing time of the machines is 30 seconds in the stage A, 1 minute and 30 seconds in the stage
B and 2 minutes and 30 seconds in the stage C, the threshold time is equal to 1 minute. This
representation of the graphic is the same as the other graphics shown in this thesis.
114
Figure 0–8: Routing phase effect: ProcTime=(00:00:30-00:01:30-00:02:30); TT=00:01:00

It is clear that 10% of the savings is due to the routing phase. Increasing the inter arrival time the
effects of the routing phase decrease to zero because the input sends the job in the system more and
more slowly and the stages do not have to decide what machine the job has to go to since there will
be just one machine that works whereas the other will remain in standby state.
We are going to analyse the two energy policies showing how the performance variables in output
change when the variables in input change.
6.3 Inter Arrival Time Variation Effects

First we have carried out an analysis on what happens when the inter arrival time varies without
modifying the processing time of the machines and the threshold time.
Tables 14, 15, 16 and figures 6-9, 6-10, 6-11 show three examples of savings trend compared to the
base case.

Threshold Inter Processing time of the machines in ∆ Energy ∆ Energy

time arrival the stages saving MN 1- saving MN 2-
time BC BC
115
00:01:00 00:00:00 00:00:30 00:01:30 00:02:30 38.63% 41.25%
00:01:00 00:00:30 00:00:30 00:01:30 00:02:30 39.05% 48.15%
00:01:00 00:01:00 00:00:30 00:01:30 00:02:30 39.52% 47.87%
00:01:00 00:01:30 00:00:30 00:01:30 00:02:30 38.65% 47.40%
00:01:00 00:02:00 00:00:30 00:01:30 00:02:30 41.87% 48.11%
00:01:00 00:02:30 00:00:30 00:01:30 00:02:30 41.94% 46.40%
00:01:00 00:03:00 00:00:30 00:01:30 00:02:30 45.53% 49.30%
00:01:00 00:03:30 00:00:30 00:01:30 00:02:30 46.33% 49.61%
00:01:00 00:04:00 00:00:30 00:01:30 00:02:30 48.21% 49.75%
00:01:00 00:04:30 00:00:30 00:01:30 00:02:30 49.99% 49.99%
Table 14: Variables value combinations used in figure 6-9
Figure 0–9: IAT variation effects: ProcTime=(00:00:30-00:01:30-00:02:30); TT=00:01:00

Inter ∆ Energy ∆ Energy
Threshold Processing time of the machines in the
arrival saving MN saving MN
time Stages
time 1-BC 2-BC
00:01:30 00:00:00 00:00:30 00:01:30 00:04:30 39.00% 47.80%
00:01:30 00:00:30 00:00:30 00:01:30 00:04:30 39.43% 48.34%
116
00:01:30 00:01:00 00:00:30 00:01:30 00:04:30 42.18% 48.61%
00:01:30 00:01:30 00:00:30 00:01:30 00:04:30 42.54% 48.89%
00:01:30 00:02:00 00:00:30 00:01:30 00:04:30 40.91% 48.54%
00:01:30 00:02:30 00:00:30 00:01:30 00:04:30 41.15% 48.65%
00:01:30 00:03:00 00:00:30 00:01:30 00:04:30 43.37% 48.76%
00:01:30 00:03:30 00:00:30 00:01:30 00:04:30 45.47% 49.15%
00:01:30 00:04:00 00:00:30 00:01:30 00:04:30 45.98% 49.37%
00:01:30 00:04:30 00:00:30 00:01:30 00:04:30 46.89% 49.23%

Figure 0–10: IAT variations effect: ProcTime=(00:00:30-00:01:30-00:04:30); TT=00:01:30
Threshold Inter Processing time of the machines in the ∆ Energy ∆ Energy

time arrival stages saving MN saving MN
time 1-BC 2-BC
00:01:00 00:00:00 00:00:30 00:01:30 00:04:30 42.60% 47.80%
00:01:00 00:00:30 00:00:30 00:01:30 00:04:30 43.67% 48.95%
00:01:00 00:01:00 00:00:30 00:01:30 00:04:30 44.59% 49.19%
00:01:00 00:01:30 00:00:30 00:01:30 00:04:30 44.67% 49.07%
117
00:01:00 00:02:00 00:00:30 00:01:30 00:04:30 44.89% 49.13%
00:01:00 00:02:30 00:00:30 00:01:30 00:04:30 45.10% 48.79%
00:01:00 00:03:00 00:00:30 00:01:30 00:04:30 45.33% 49.00%
00:01:00 00:03:30 00:00:30 00:01:30 00:04:30 46.32% 49.45%
00:01:00 00:04:00 00:00:30 00:01:30 00:04:30 46.52% 49.60%
00:01:00 00:04:30 00:00:30 00:01:30 00:04:30 47.90% 49.78%
Figure 0–11: IAT variation effect: ProcTime=(00:00:30-00:01:30-00:04:30); TT=00:01:00
In all the experiments when IAT increases the possibility for the stage to set the machine to standby
increases since the jobs go in the system more slowly and therefore the possibility that within TT
there are no jobs to be worked increases. Thus we can say that without changing the other variables
the increase of IAT causes an increase of energy saving compared to the base case.
In the three cases (figures 6-9, 6-10, 6-11) the increasing saving settles to a precise value that in our
experiments is always about 50%. In the base case the possible energy states of the machines are
two: working state and idle state. During the time necessary to process the jobs the machines are in
working state and in the remaining time in idle state. Applying the energy policies we have
introduced another energy state that is the standby state and have reduced the idle state setting the
machine to standby state whenever possible since the standby state allows a reduction of energy
consumption compared to idle state considering the same period of time.
In a few words we work on the energy state of the machines when they do not have to work
118
changing their energy state. Equations 16 and 17 summarize this procedure in the Manzone Nervi 1
policy and the Manzone Nervi 2 policy respectively:
𝐼𝑑𝑙𝑒𝑇𝑖𝑚𝑒pq = 𝐼𝑑𝑙𝑒𝑇𝑖𝑚𝑒rsU + 𝑆𝑡𝑎𝑛𝑑𝑏𝑦𝑇𝑖𝑚𝑒rsU
Equation 16: Thesis objective

𝐼𝑑𝑙𝑒𝑇𝑖𝑚𝑒pq = 𝐼𝑑𝑙𝑒𝑇𝑖𝑚𝑒rsu + 𝑆𝑡𝑎𝑛𝑑𝑏𝑦𝑇𝑖𝑚𝑒rsu
Equation 17: Thesis objective
The maximum possible energy saving during production can be expressed as the relationship
between the powers in standby and idle state:
𝑆𝑡𝑎𝑛𝑑𝑏𝑦𝑃𝑜𝑤𝑒𝑟
𝑀𝑎𝑥𝑆𝑎𝑣𝑖𝑛𝑔 =
𝐼𝑑𝑙𝑒𝑃𝑜𝑤𝑒𝑟
Equation 18: Max Saving

After verifying that energy saving increases compared to the base case when IAT increases, we
have carried out a deeper analysis trying to understand exactly how many times our energy policies
are applied.
Threshold Inter Processing time of the machines in ∆ #standby ∆ #standby

time arrival the stages times MN 1 times MN 2
time -BC -BC
00:00:30 00:00:00 00:00:30 00:01:30 00:04:30 1567 1610
00:00:30 00:00:30 00:00:30 00:01:30 00:04:30 2379 2956
00:00:30 00:01:00 00:00:30 00:01:30 00:04:30 3258 4080
00:00:30 00:01:30 00:00:30 00:01:30 00:04:30 3769 4225
00:00:30 00:02:00 00:00:30 00:01:30 00:04:30 3728 4574
00:00:30 00:02:30 00:00:30 00:01:30 00:04:30 5061 5975
00:00:30 00:03:00 00:00:30 00:01:30 00:04:30 5897 6835
00:00:30 00:03:30 00:00:30 00:01:30 00:04:30 6549 7718
00:00:30 00:04:00 00:00:30 00:01:30 00:04:30 6848 7573
119
00:00:30 00:04:30 00:00:30 00:01:30 00:04:30 7460 8128
00:00:30 00:06:30 00:00:30 00:01:30 00:04:30 9000 9000
00:00:30 00:07:00 00:00:30 00:01:30 00:04:30 9000 9000
The data used for the second example are shown in table 18:
Threshold Inter Processing time of the machines in ∆ #standby ∆ #standby

time arrival the stages times MN 1 times MN 2
time -BC -BC
00:01:00 00:00:00 00:00:30 00:01:30 00:02:30 254 488
00:01:00 00:00:30 00:00:30 00:01:30 00:02:30 489 1338
00:01:00 00:01:00 00:00:30 00:01:30 00:02:30 1192 2183
00:01:00 00:01:30 00:00:30 00:01:30 00:02:30 2208 3381
00:01:00 00:02:00 00:00:30 00:01:30 00:02:30 3235 5135
00:01:00 00:02:30 00:00:30 00:01:30 00:02:30 4634 6030
00:01:00 00:03:00 00:00:30 00:01:30 00:02:30 5578 6888
120
00:01:00 00:03:30 00:00:30 00:01:30 00:02:30 5759 7157
00:01:00 00:04:00 00:00:30 00:01:30 00:02:30 6703 7635
00:01:00 00:04:30 00:00:30 00:01:30 00:02:30 9000 9000
00:01:00 00:05:00 00:00:30 00:01:30 00:02:30 9000 9000
00:01:00 00:05:30 00:00:30 00:01:30 00:02:30 9000 9000
As already shown in the previous analysis when IAT increases the possibility for the machines to be
in standby state after working increases allowing an energy saving and this is further confirmed by
graphics 6-12 and 6-13 where it is clear that whenever IAT increases the number of times the
machines go to standby increases and obviously with the Manzone Nervi 2 policy it is always
higher than the one of the the Manzone Nervi 1 policy, the Manzone Nervi 2 policy allowing a
higher energy saving.
Nevertheless in all the cases at a certain IAT the number of times the machine are set to standby is
the same for both policies and in particular it always settles to a precise number that in our cases is
9,000. This is due to the fact that if the inter arrival time is equal to the minimum jobs flow time and
therefore to the time required for a job to be worked not having to wait in the buffer before going to
the machine, the jobs enter in the system one by one and each machine switches to standby after
working. Considering the jobs are 3,000 the energy policy will be applied maximum 3,000 times in
each single stage; multiplying this number by the number of stages in the system the result is
121
exactly 9,000 times.
We have proved that applying our policies it is possible to increase energy savings increasing IAT.
This statement shall be given a monetary value to have more relevance as for its actual application
in manufacturing. Increasing IAT economic savings increase since costs relative to the energy
required to maintain a machine in idle state are reduced and replaced by the costs relative to the
energy required to maintain it in standby state. The power required to maintain a machine in idle
state is higher than the power required by a machine in standby and consequently the actual final
costs are inferior applying the energy policies. Anyway it has to be underlined that makespan
increases as well when IAT increases and therefore in the same period the quantity of worked jobs
is inferior, this resulting in a minor production value added compared to the case with a minor IAT.
Another effect of the inter arrival time is linked to the saturation of the machines in the system
during production. It is possible to understand in advance what the trend of a graphic used to show
the system saturation trend can be when IAT varies, nevertheless we have proved it as figures 6-14
and 6-15 indicate. Table 19 summarizes the data of the first example:
Threshold Inter arrival Saturation

Processing time of the machines in the stages
time time system

00:01:00 00:00:00 00:01:30 00:01:30 00:01:30 99.97%
00:01:00 00:00:30 00:01:30 00:01:30 00:01:30 99.86%
00:01:00 00:01:00 00:01:30 00:01:30 00:01:30 74.84%
00:01:00 00:01:30 00:01:30 00:01:30 00:01:30 49.97%
00:01:00 00:02:00 00:01:30 00:01:30 00:01:30 37.49%
00:01:00 00:02:30 00:01:30 00:01:30 00:01:30 29.99%
00:01:00 00:03:00 00:01:30 00:01:30 00:01:30 25.00%
00:01:00 00:03:30 00:01:30 00:01:30 00:01:30 21.43%
00:01:00 00:04:00 00:01:30 00:01:30 00:01:30 18.75%
00:01:00 00:04:30 00:01:30 00:01:30 00:01:30 16.67%
122
Figure 0–14: IAT effect on system saturation: ProcTime=(00:01:30-00:01:30-00:01:30); TT=00:01:00

Table 20 summarizes the data of the second example:
Threshold Inter arrival System

Processing time of the machines in the stages
time time saturation

00:01:00 00:00:00 00:00:30 00:01:30 00:02:30 59.98%
00:01:00 00:00:30 00:00:30 00:01:30 00:02:30 59.97%
00:01:00 00:01:00 00:00:30 00:01:30 00:02:30 59.97%
00:01:00 00:01:30 00:00:30 00:01:30 00:02:30 49.97%
00:01:00 00:02:00 00:00:30 00:01:30 00:02:30 37.48%
00:01:00 00:02:30 00:00:30 00:01:30 00:02:30 29.99%
00:01:00 00:03:00 00:00:30 00:01:30 00:02:30 25.00%
00:01:00 00:03:30 00:00:30 00:01:30 00:02:30 21.43%
00:01:00 00:04:00 00:00:30 00:01:30 00:02:30 18.75%
00:01:00 00:04:30 00:00:30 00:01:30 00:02:30 16.67%
123

Figure 0–15: IAT effect on system saturation: ProcTime =(00:00:30-00:01:30-00:02:30); TT=00:02:00
It is clear that the system is less saturated when the inter arrival time increases, actually when IAT
increases the input sends the job to the system more slowly and consequently the machines have to
wait longer between two operations.
6.4 Threshold Time Variation Effects

In this paragraph we are going to analyse what happens when the threshold time varies but not the
processing time of the machines and the inter arrival time. We expect two contradictory trends:
- percentage decrease of energy saving compared to the base case: after a machine finishes
working the stage asks the input and the other stages whether a job is going to arrive within
TT (the Manzone Nervi 1 policy) or two jobs are going to arrive within TT+ProcTime (the
Manzone Nervi 2 policy). Without changing the other variables, if the TT value increases
the possibility for the machines not to be switched to standby is higher, therefore savings in
a case with a high TT are inferior to savings in a case with a low TT. In the Manzone Nervi
2 policy we expect this trend to be less evident than in the Manzone Nervi 1 policy, as a
matter of fact the Manzone Nervi 2 policy provides for the machines to be set to standby in
some cases even if the job is arriving within TT but the second job is arriving within
TT+ProcTime;
- once the stage switches a machine to standby, the possibility for the machine to be set to idle
state is less; in fact when a job arrives in the buffer, the stage checks if there is a machine in
124
idle, that being the case, it gives the job to the machine, otherwise the stage verifies if there
is a machine in working state and if so calculates the remaining processing time. If the
remaining processing time of the machine Mi that is working is inferior to TT the machine
Mi is given the job so that the machine that had been switched to standby state is not set to
idle state again.
Below are two experiments taken as example showing the percentage saving of the Manzone Nervi
1 policy compared to the case base and the Manzone Nervi 2 policy compared to the case base
varying TT.
Table 21 shows the variables value combinations used:

time arrival the stages saving MN 1 saving MN 2
time -BC -BC
00:00:30 00:02:00 00:00:30 00:01:30 00:04:30 46.16% 49.57%
00:01:00 00:02:00 00:00:30 00:01:30 00:04:30 44.89% 49.13%
00:01:30 00:02:00 00:00:30 00:01:30 00:04:30 40.91% 48.58%
00:02:00 00:02:00 00:00:30 00:01:30 00:04:30 39.51% 48.00%
00:03:00 00:02:00 00:00:30 00:01:30 00:04:30 37.87% 47.40%
Table 21 Variables value combinations used in figure 6-16
Figure 0–16: TT variation effect: ProcTime=(00:00:30-00:01:30-00:04:30); IAT=00:02:00
125
As for the second example the variables value combinations are shown in table 22:

time arrival the stages saving MN 1 saving MN 2
time -BC -BC
00:00:30 00:02:00 00:01:40 00:02:20 00:03:10 42.94% 47.95%
00:01:00 00:02:00 00:01:40 00:02:20 00:03:10 38.17% 46.44%
00:01:30 00:02:00 00:01:40 00:02:20 00:03:10 36.48% 45.22%
00:02:00 00:02:00 00:01:40 00:02:20 00:03:10 34.56% 45.12%
00:03:00 00:02:00 00:01:40 00:02:20 00:03:10 30.22% 44.32%
Figure 0–17: TT variation effect: ProcTime=(00:01:40-00:02:20-00:03:10); IAT=00:02:00
In both examples (figures 6-16 and 6-17) it is possible to notice that the first trend is more evident
than the second one, therefore increasing TT the percentage saving compared to the base case
decreases. The Manzone Nervi 2 policy allows an almost maximum saving for each example for the
reason described above, anyway varying TT there is a decrease in savings.
126
6.4.1 The Manzone Nervi 1 Policy Non-implementation Probability

Two questions arise when noticing this decrease: is there a TT that prevents this policy from
working? If yes, which one?
The answer to the first question in simple, it is yes; in fact should we set TT equal to the total time
required to complete the whole production (simulation time) the policies would never apply since
the stage would not switch the machine to standby after working because there would be a job
arriving within TT.
Let’s focus on the second question now and let’s try to understand what the TT is for which the
policies cannot be applied. We have carried out an analysis of the Manzone Nervi 1 policy and then
of the Manzone Nervi 2 policy.
Considering the system without the transitory phases, if each stage after its machines finish working
finds a number of jobs arriving within TT equal or superior to the number of the machines in the
stage, the policy is not applied and therefore all the machines in the system are not set to standby.
If the stage with the fastest processing times always receives a number of jobs within TT equal or
superior to the number of the machines in the stage it means that in that stage the policy is not
applied but if TT has a value not allowing the policy implementation in this stage it means that the
policy cannot be applied to the other stages as well that surely have a buffer with more jobs because
they have slower processing times.
The arrival of a job in a specific stage depends on the other stages working times, the inter arrival
time and the job sequence that in our case is random. Due to the several variables the arrival of the
job in the stage depends on it is not possible to define the fixed TT that in all the situations does not
allow the policy implementation, but given precise values of IAT and machines processing times it
is possible to calculate the policy non-implementation probability.
It is therefore a problem of probability so it is necessary to calculate the probability that in the stage
as many jobs as the number of machines in the stage itself arrive within TT, this stage being the one
where the machines have the shortest processing time.
Before calculating it, it is necessary to define how many jobs circulate in the system during an
interval time equal to TT and how many events occur in the same interval. An “event” occurs when
a job is sent to the system by the input or when it is finished by a machine.
127
Calculating the events with regard to the input and the bottleneck stage is simple because for the
input we just have to calculate the relationship between the threshold time and the inter arrival time,
whereas for the bottleneck stage we have to calculate the relationship between the threshold time
and the processing time and multiply this result by the number of machines in the bottleneck stage.
Calculating the events relative to the stage which is neither the fastest nor the bottleneck one is
more complex because this stage unlike the bottleneck stage does not always have the buffer with
jobs inside. Since we want to calculate when the policy does not apply in the fastest stage, it implies
that the policy surely does not apply either in this stage, therefore we can affirm that it will surely
receive two jobs within TT but we cannot affirm that it will surely finish working the two jobs
within TT.
As a consequence within TT this stage will be able to send the system either zero jobs or as many
jobs as the relationship between the threshold time and the processing time multiplied by the
number of machines in the stage. Expressing this concept with a formula and defining therefore the
minimum and maximum number of events likely to occur within TT we can write:
𝑇𝑇 𝑇𝑇
𝑛cEF = + ∗ #𝑚𝑎𝑐ℎ𝑛𝑒𝑠yDGJIz
𝐼𝑛𝑡𝑒𝑟 𝑎𝑟𝑟𝑖𝑣𝑎𝑙 𝑡𝑖𝑚𝑒 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJIz
Equation 19: Calculation of the minimum number of jobs in the system in TT in the Manzone Nervi 1 policy
𝑇𝑇 𝑇𝑇
𝑛cG} = + ∗ #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJIz
𝐼𝐴𝑇 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJIz
𝑇ℎ𝑟𝑒𝑠ℎ𝑜𝑙𝑑 𝑡𝑖𝑚𝑒
+ ∗ #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJI•
𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJI•
Equation 20: Calculation of the maximum number of jobs in the system in TT in the Manzone Nervi 2 policy

Where:
- 𝑛cEF : minimum number of events in TT;
- 𝑛cG} : maximum number of events in TT.
Once defined the possible events in TT, that is the number of jobs likely to circulate in the system
during TT, we calculate the probability that in the stage as many jobs as the number of the machines
128
in the stage itself arrive within TT, this stage being the one where the machines have the shortest
processing time and thus the probability that the Manzone Nervi 1 policy does not apply.
Given a minimum and maximum number of events likely to occur we have to calculate the
following probability formula first considering nmin and then nmax. The probability that the Manzone
Nervi 1 policy is not applied is equal to the range delimited by the two just calculated probabilities.
STU STU
RVU RVU
Equation 21: The Manzone Nervi 1 policy non-implementation probability
Where:
- P0=(1-p)n: probability that given n events there is no success, that is given n circulating jobs
in the system during TT no job is sent to the stage with the fastest processing times;
STU F
- RVU 𝑃R,F = R
𝑝R ∗ 1 − 𝑝 FTR
: probability that given n events there are k successes, that is
given n circulating jobs in the system during TT there are k jobs sent to the stage with the
fastest processing times;
- p: success probability;
- k: number of successes equal to the number of machines in the stage with the fastest
processing times, here #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJI€ = 2, therefore k=2.
We are going to show a numerical example of calculation of the Manzone Nervi 1 policy non-
implementation probability (from equation 22 to equation 31).
The data of the example are: ProcTime=(00:01:40-00:02:20-00:03:10), IAT=00:02:00,

TT=00:03:00. In this case the fastest stage is the Stage A and the bottleneck is the stage C and all
the times are expressed in seconds. In our case p is equal to 2/6 because considering the paths of the
6 different jobs typologies, whenever the input or the Stages B and C send a job in the system there
is a probability of 2/6 that the job is going to the stage A.
𝑇𝑇 𝑇𝑇 180 180
𝑛cEF = + ∗ #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJIz = + ∗ 2 = 3.39 ≈ 3
𝐼𝐴𝑇 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJIz 120 190
Equation 22: Calculation of the minimum number of jobs in the system in TT
129
𝑇𝑇 𝑇𝑇 𝑇𝑇
𝑛cG} = + ∗ #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJIz + ∗ #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJI•
𝐼𝐴𝑇 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJIz 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJI•
180 180 180
= + ∗2 + ∗ 2 = 5.96 ≈ 5
120 190 140
Equation 23: Calculation of the maximum number of jobs in the system in TT

STU STU
RVU RVU
Equation 24:The Manzone Nervi 1 policy non-implementation probability
‰
F
2
𝑃N,FOPQ = (1 − 𝑝) = 1 − = 0,29
6
Equation 25: Calculation of 𝑃N,FOPQ
ŠTU U ‰TU
𝑛 R FTR
3 2 2
𝑃R,FOPQ = 𝑝 ∗ 1−𝑝 = ∗ ∗ 1− = 0.44
𝑘 1 6 6
‹VU
STU
Equation 26: Calculation of RVU 𝑃R,FOPQ
STU
1 − 𝑃N,FOPQ − 𝑃R,FOPQ = 1 − 0.29 − 0.44 = 0.27

RVU
Equation 27: Calculation of the Manzone Nervi 1 policy non-implementation minimum probability
Ž
F
2
𝑃N,FO^_ = (1 − 𝑝) = 1 − = 0.13
6
Equation 28: Calculation of 𝑃N,FO^_
ŠTU U ŽTU
𝑛 R FTR
5 2 2
𝑃R,FO^_ = 𝑝 ∗ 1−𝑝 = ∗ ∗ 1− = 0.32
𝑘 1 6 6
‹VU
STU
Equation 29: Calculation of RVU 𝑃R,FO^_
STU
1 − 𝑃N,FO^_ − 𝑃R,FO^_ = 1 − 0.13 − 0.32 = 0.55

RVU
Equation 30: Calculation of the Manzone Nervi 1 policy non-implementation maximum probability
130
27% < 𝑀𝑁1 𝑛𝑜𝑛– 𝑖𝑚𝑝𝑙𝑒𝑚𝑒𝑛𝑡𝑎𝑡𝑖𝑜𝑛 𝑝𝑟𝑜𝑏 < 55%
Equation 31: Calculation the Manzone Nervi 1 policy non-implementation probability
Tables 23, 24 and figures 6-18, 6-19 contain two examples to define the Manzone Nervi 1 policy
non-implementation probability varying TT.
Threshold Inter Processing time of the machines in the Min Max

time arrival stages probability probability
time
00:00:30 00:02:00 00:01:40 00:02:20 00:03:10 0.00% 0.00%
00:01:00 00:02:00 00:01:40 00:02:20 00:03:10 1.00% 1.00%
00:01:30 00:02:00 00:01:40 00:02:20 00:03:10 1.00% 12.00%
00:02:00 00:02:00 00:01:40 00:02:20 00:03:10 12.00% 27.00%
00:03:00 00:02:00 00:01:40 00:02:20 00:03:10 27.00% 54.00%
00:04:30 00:02:00 00:01:40 00:02:20 00:03:10 54.00% 81.00%
00:05:00 00:02:00 00:01:40 00:02:20 00:03:10 54.00% 85.40%
00:06:00 00:02:00 00:01:40 00:02:20 00:03:10 65.00% 93.00%
00:08:00 00:02:00 00:01:40 00:02:20 00:03:10 85.40% 97.80%
00:10:00 00:02:00 00:01:40 00:02:20 00:03:10 93.00% 99.50%
00:12:00 00:02:00 00:01:40 00:02:20 00:03:10 96.50% 99.90%
131

Figure 0–18: TT variation effect on the Manzone Nervi 1 policy non-implementation probability: ProcTime=(00:01:40-
00:02:20-00:03:10); IAT=00:02:00
Table 24 contains the data used for the second example:

time
00:00:30 00:02:00 00:00:30 00:01:30 00:04:30 0.00% 1.00%
00:01:00 00:02:00 00:00:30 00:01:30 00:04:30 0.00% 12.00%
00:01:30 00:02:00 00:00:30 00:01:30 00:04:30 1.00% 27.00%
00:02:00 00:02:00 00:00:30 00:01:30 00:04:30 1.00% 41.00%
00:03:00 00:02:00 00:00:30 00:01:30 00:04:30 12.00% 65.00%
00:04:30 00:02:00 00:00:30 00:01:30 00:04:30 41.00% 89.00%
00:05:00 00:02:00 00:00:30 00:01:30 00:04:30 41.00% 96.00%

00:06:00 00:02:00 00:00:30 00:01:30 00:04:30 54.00% 96.50%
00:08:00 00:02:00 00:00:30 00:01:30 00:04:30 74.00% 99.30%
00:10:00 00:02:00 00:00:30 00:01:30 00:04:30 85.40% 99.89%
00:12:00 00:02:00 00:00:30 00:01:30 00:04:30 93.00% 99.90%
Table 24 Variables value combinations used in figure 6-19
132
00:01:30-00:04:30); IAT=00:02:00
6.4.2 The Manzone Nervi 2 Policy Non-implementation Probability

As for the Manzone Nervi 2 policy non-implementation the logic is similar to the one of the
Manzone Nervi 1 with the only difference that after the machines in the stage having the fastest
processing times finish working, the stage will not set them to standby if within TT+ProcTime as
many jobs arrive as the double of the number of machines in the stage. This happens because to
prevent the machines from being switched to standby they shall have the possibility of working two
jobs each within a time equal to the threshold time plus their processing time; in fact should only
one job for each machine arrive within this time the machines would be switched to standby.
The following formulas can be used to calculate the minimum and maximum events:
𝑇𝑇 + 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJI€ 𝑇𝑇 + 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJI€
𝑛cEF = + ∗ #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJIz
133
𝑇𝑇 + 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJI€ 𝑇𝑇 + 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJI€
𝑛cG} = + ∗ #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJIz
𝑇𝑇 + 𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJI€
+ ∗ #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJI•
𝑃𝑟𝑜𝑐𝑇𝑖𝑚𝑒yDGJI•
Where:
- 𝑛cEF : minimum number of events in TT;
- 𝑛cG} : maximum number of events in TT.
The probability calculation is the one previously described, therefore we can write:
STU STU
RVU RVU
Where:
n
- 𝑃N,F =(1-p) : probability that given n events there is no success, that is given n circulating
jobs in the system during TT no job is sent to the stage with the fastest processing times;
Š F
- ‹VU PR,F = R
𝑝R ∗ 1 − 𝑝 FTR
: probability that given n events there are k successes, that is
given n circulating jobs in the system during TT there are k jobs sent to the stage with the
fastest processing times;
- p: success probability;
- k: number of successes equal to the number of machines in the stage with the fastest
processing times, here #𝑚𝑎𝑐ℎ𝑖𝑛𝑒𝑠yDGJI€ = 2, therefore k=4;
The value of k in the Manzone Nervi 2 policy is always the double compared to the value of k in the
Manzone Nervi 1 policy. In our case given two machines in each stage, applying the Manzone
Nervi 1 policy the number of successes is two and applying the Manzone Nervi 2 policy it is four.
134
Table 25 contains the data of the first example:

time
00:00:30 00:02:00 00:00:30 00:01:30 00:04:30 0.00% 0.00%
00:01:00 00:02:00 00:00:30 00:01:30 00:04:30 0.00% 0.00%
00:01:30 00:02:00 00:00:30 00:01:30 00:04:30 0.00% 1.00%
00:02:00 00:02:00 00:00:30 00:01:30 00:04:30 0.00% 5.00%
00:03:00 00:02:00 00:00:30 00:01:30 00:04:30 0.00% 17.00%
00:04:30 00:02:00 00:00:30 00:01:30 00:04:30 1.00% 53.00%
00:05:00 00:02:00 00:00:30 00:01:30 00:04:30 5.00% 60.30%
00:06:00 00:02:00 00:00:30 00:01:30 00:04:30 10.00% 73.70%
00:08:00 00:02:00 00:00:30 00:01:30 00:04:30 27.00% 92.95%
00:10:00 00:02:00 00:00:30 00:01:30 00:04:30 35.00% 97.30%
00:12:00 00:02:00 00:00:30 00:01:30 00:04:30 53.00% 99.40%
00:01:30-00:04:30); IAT=00:02:00
Table 26 contains the data of the second example:

135
time
00:00:30 00:02:00 00:01:40 00:02:20 00:03:10 0.00% 0.00%
00:01:00 00:02:00 00:01:40 00:02:20 00:03:10 0.00% 0.00%
00:01:30 00:02:00 00:01:40 00:02:20 00:03:10 0.00% 0.00%
00:02:00 00:02:00 00:01:40 00:02:20 00:03:10 0.00% 1.00%
00:03:00 00:02:00 00:01:40 00:02:20 00:03:10 0.00% 10.00%
00:04:30 00:02:00 00:01:40 00:02:20 00:03:10 5.00% 35.00%
00:05:00 00:02:00 00:01:40 00:02:20 00:03:10 10.00% 44.00%
00:06:00 00:02:00 00:01:40 00:02:20 00:03:10 17.00% 82.90%
00:08:00 00:02:00 00:01:40 00:02:20 00:03:10 35.00% 82.90%
00:10:00 00:02:00 00:01:40 00:02:20 00:03:10 53.00% 94.90%
00:12:00 00:02:00 00:01:40 00:02:20 00:03:10 73.70% 98.50%

00:02:20-00:03:10); IAT=00:02:00
136
7. CONCLUSIONS AND FURTHER
DEVELOPMENTS
7.1 Conclusions
Energy efficiency is becoming a more and more relevant issue in manufacturing. As widely
explained in our work it is an important criterion to consider when evaluating the sustainability and
efficiency of a company, besides it can help reduce costs.
Our work aims to contribute to the research on energy efficiency in manufacturing through the
creation of our two policies: “The Manzone Nervi 1 policy” and “The Manzone Nervi 2 policy”.
Our work follows the current trend in industry and research aiming at reducing energy consumption
during production by means of ‘energy saving’ enabled machines and novel sophisticated ICT
system based on embedded system, the Internet of Things, cloud computing etc. In particular in our
work we have develop novel energy saving policies enabling autonomous switching self-aware
machines, otherwise in idle state, in a standby state, characterized by low power consumption, by
exploiting the possibility of interoperable communication among the machines in the same job shop
system. Accordingly, our approach is aligned as well with current 4.0 vision towards the future
cyber physical production system
During our work we have tried to give an answer to the research questions indicated in chapter 3.
137
How can the energy efficiency of a job shop production system be improved applying the Current
Job Aware and Current and Next Job Aware energy policies that have been designed for a line
production?
The development of this thesis shall be obviously supported by an ICT infrastructure that allows the
stages and the input to communicate with each other, exchange real time information and make real
time decisions on the matter.
As a matter of fact our work wants to represent an evolution comparing the existing models and
mainly contributes to two fields of research:
- the energy-saving policies;
- the information update in real time through ICT infrastructures.
Thanks to the energy policies implementation in a system where information is exchanged in real
time we have been able to prove that it is possible to actually obtain significant energy savings and
consequently costs reductions.
Obviously before drawing these conclusions we have carried out a literature review on energy
efficiency in manufacturing and energy policies to be applied to the different production systems.
During our literature analysis to the best of our knowledge we have found that our approach has
never be applied to a job shop production system. This system has been studied by several authors
even if not deeply like the serial line and the flow line production. The most interesting policies we
have considered on the basis of our work are the one written by May et al. [37] and Rapuzzi [2]: the
first considers a job shop system but not the real time communication, the second deals with the real
time communication among the machines in the system but it is applied on a serial line production.
We have then decided to start from the energy policies developed by Rapuzzi and adapt them to a
job shop system introducing innovative elements. Our policies are composed of two phases:
- routing phase: this is the most innovative aspect of our thesis and it starts whenever a job is
in the buffer and the stage chooses what machine has to process it;
- decisional state on a machine energy state: it starts whenever a machine finishes working and
the stage decides either to leave the machine in idle state or to set it to standby state.
Moreover our policies can be associated to the configuration level of Jay Lee model [45] (figure 2-
138
6), it means that each component and machine can predict and prevent situations and further self-
aware, self-predict, self-compare and self-reconfigure and self-optimize for robust intelligence and
performance.
For this purpose we have developed conceptual models able to describe our policies. Then we have
carried out a lot of experiments using the Tecnomatix Plant Simulation v12 simulator for which it
has been necessary to write a code allowing us to implement our policies.
The results of our experiments prove that applying the Manzone Nervi 1 policy and Manzone Nervi
2 policy it is possible to have potential savings up to about 40% compared to the base case without
policies, with an increase of makespan by about 0.01%.
7.2 Further Developments
Monitoring energy efficiency in a company is essential not only from an economic but also from an
environmental point of view.
For this reason it is necessary to further develop this issue, in particular focusing on the following
steps:
- increasing the system complexity as follows:
o introducing generic machines with different processing times and powers in the
stages;
o increasing the number of machines in the stage and/or the number of stages in the
system;
- reducing the buffer capacity: in our work we have considered oversized buffers to simplify
the model. For this reason we have not developed Rapuzzi’s third policy [2] that provides
for controls of the available room in the buffers. It might be interesting to understand how to
adapt this policy to a job shop system and what impact it has on the buffer dimension as far
as energy savings are concerned;
- the machines we have used in this work during simulation are not subject to failures, so it
would be interesting to introduce this variable to see how it affects energy savings. Besides
maintenance planning might be contemplated.
In conclusion we think that the results we have reached can extend the traditional control policies in
139
manufacturing and our work can be a crucial starting point for the definition of more precise
policies to be applied to specific cases.
Bibliography

[1] M. Macchi e S. Terzi, Modellazione dei Sistemi Produttivi, vol. 2, Bologna , Bo: Pitagora
Editrice, 2009, pp. 1-8.
[2] N. Rapuzzi, Energy-aware control policies for autonomous machines in a flow-line, Milano,
2015.
[3] G. Bruntland, Il futuro di noi tutti, Rapporto della Commisione Mondiale per l'Ambiene e lo
Sviluppo, Milano: Bompiani, 1988, pp. 32-78.
[4] «Voce: Rapporto Brundtland,» 16 dicembre 2014. [Online]. Available:
https://it.wikipedia.org/wiki/Rapporto_Brundtland.
[5] G. Brundtland, Il futuro di noi tutti, Commissione Mondiale per l'Ambiente e lo Sviluppo,
Milano, Mi: Bompiani, 1988, pp. 321-388.
[6] «Archivio documenti,» [Online]. Available: http://www.terna.it/archiviodocumenti.aspx.
[7] «Dati statistici,» 2016. [Online]. Available:
http://www.autorita.energia.it/it/dati/elenco_dati.htm.
[8] AEEGSI, «Relazione annuale sullo stato dei servizi e sull'attività svolta,» 2015.
[9] M. Patterson, «What is energy efficiency? Concepts, indicators and methodological issues,»
Energy Policy, pp. 377-390, maggio 1996.
[10] «Sistema elettrico: Consumi energia elettrica per settore,» 2014. [Online]. Available:
140
http://www.terna.it/it-
it/sistemaelettrico/statisticheeprevisioni/consumienergiaelettricapersettoremerceologico.aspx .
[11] C. Walsh e P. Thornley, «Barriers to improving energy efficiency withinhe process industries
with a focus on low grade heat utilisation,» Journal of Cleaner Production, pp. 138-146, 9
novembre 2011.
[12] M. Garetti e M. Taisch, «Sustainable manufacturing: trends and research challenges,»
Production Planning & Control: The Management of Operations, vol. 23, n. 2-3, pp. 83-104,
2012.
[13] D. Min, T. Dunbing, Z. Haitao e Y. Jun, «Energy-aware Scheduling Model and Optimization
for a Flexible Flow Shop Problem,» in Chinese Control and Decision Conference, Nanjing,
Fengyang, 2014.
[14] G. May, I. Barletta, B. Stahl e M. Taisch , «Energy management in production: A novel
method to develop key performance indicators for improving energy efficiency,» Applied
Energy, pp. 46-61, 2015.
[15] F. Shrouf , J. Ordieres-Meré, A. García-Sánchez e M. Ortega-Mier , «Optimizing the
production scheduling of a single machine to minimize total energy consumption costs,» pp.
197-207, 2014.
[16] H.-S. Yoon, E.-S. Kim, J.-Y. Lee, G.-B. Lee e S.-H. Ahn, «Towards greener machine tools – A
review on energy saving strategies and technologies,» Renewable and Sustainable Energy
Reviews , p. 870–891, 2015.
[17] G. Mert, S. Waltemode e J. C. Aurich, «How services influence the energy efficiency of
machine tools: a case study of a machine tool manufacturer,» in The 22th CIRP conference on
Life cycle Engineering, 2015.
[18] «scientific journal rankings,» [Online]. Available: http://www.scimagojr.com/journalrank.php.
[19] D. G. Maringer, Portfolio Management with Heuristic Optimization, Springer, 2005, p. 38.
[20] R. Martí e G. Reinelt, The Linear Ordering Problem, Springer, 2011.
[21] X. Liu, F. Zou e X. Zhang, «Mathematical Model and Genetic Optimization for Hybrid Flow
Shop Scheduling Problem Based on Energy Consumption,» in Chinese Control and Decision
Conference, Changsha, 2008.
[22] M. A. Salido, J. Escamilla, A. Giret e F. Barber, «A genetic algorithm for energy-efficiency in
job-shop scheduling,» Int J Adv Manuf Technol, 2015.
[23] X. Liu, F. Zou e X. Zhang, «Mathematical Model and Genetic Optimization for Hybrid Flow
141
Shop Scheduling Problem Based on Energy Consumption,» in Chinese Control and Decision
Conference, Changsha, 2008.
[24] Q. Yi, C. Li, Y. Tang e Q. Wang, «A new operational framework to job shop scheduling for
reducing carbon emissions,» in 8th IEEE International Conference on Automation Science and
Engineering, Seul, 2012.
[25] Y. Wang e X. Li, «Shuffled Frog Leaping Algorithm for a Bi-objective No-idle Permutation
Flow Shop,» in International Conference on Systems, Man, and Cybernetics, Nanjing, 2013.
[26] A. Cataldo, A. Perizzato e R. Scattolini, «Production scheduling of parallel machines with
model predictive control,» Control Engineering Practice, pp. 28-40, 2015.
[27] L. Li e Z. Sun, «Dynamic Energy Control for Energy Efficiency Improvement of Sustainable
Manufacturing Systems Using Markov Decision Process,» IEEE TRANSACTIONS ON
SYSTEMS, MAN, AND CYBERNETICS SYSTEMS, pp. 1-11.
[28] G. Chen, L. Zhang, J. Arinez e S. Biller, «Energy-Efficient Production Systems Through
Schedule-Based Operations,» IEEE TRANSACTIONS ON AUTOMATION SCIENCE AND
ENGINEERING, vol. 10, n. 1, pp. 27-37, 2013.
[29] T. Stock e G. Seliger, «Multi-objective Shop Floor Scheduling Using Monitored Energy
Data,» in 12th Global Conference on Sustainable Manufacturing, Berlin, 2015.
[30] T. L. Urban e . W.-C. Chiang, «Designing energy-efficient serial production lines: The
unpaced synchronous line-balancing problem,» European Journal of Operational Research, p.
789–801, 2015.
[31] Y.-C. Wang, M.-J. Wang e S.-C. Lin, «Selection of cutting conditions for power constrained
parallel machine scheduling,» Robotics and Computer-Integrated Manufacturing, 2015.
[32] K. Fang, N. Uhan, F. Zhao e J. W. Sutherland, «A new approach to scheduling in
manufacturing for power consumption and carbon footprint reduction,» Journal of
Manufacturing Systems, p. 234–240, 2011.
[33] G.-S. Liu, B.-X. Zhang, H.-D. Yang, X. Chen e G. Q. Huang, «A Branch-and-Bound
Algorithm for Minimizing the Energy Consumption in the PFS Problem,» 2013.
[34] A. Bruzzone, D. Anghinolfi, M. Paolucci e F. Tonelli, «Energy-aware scheduling for
improving manufacturing process sustainability: A mathematical model for flexible flow
shops,» CIRP Annals - Manufacturing Technology, p. 459–462, 2011.
[35] Y. He, L. Fei, C. Hua-ju e L. Congbo, «A bi-objective model for job-shop scheduling problem
to minimize both energy consumption and makespan,» J. CENT. SOUTH UNIV. TECHNOL.,
142
2005.
[36] Y. He, Y. Li, T. Wu e J. W. Sutherland, «An energy-responsive optimization method for
machine tool selection and operation sequence in flexible machining job shops,» Journal of
Cleaner Production, pp. 245-254, 2014.
[37] G. May, B. Stahl, M. Taisch e V. Prabhu , «Multi-objective genetic algorithm for energy-
efficient job shop scheduling,» International Journal of Production Research, pp. 1-19, 2015.
[38] M. Lang e H. Li, «Research on Dual-resource Multi-objective Flexible Job Shop Scheduling
under Uncertainty,» in Conference at Xidian Uinversity, 2011.
[39] Z. Jiang, L. Zuo e M. E, «Study on Multi-objective Flexible Job-shop Scheduling Problem
considering Energy Consumption,» Journal of Industrial Engineering and Management, pp.
589-604, 2014.
[40] R. Zhang, . S. Ong e A. Nee, «A simulation-based genetic algorithm approach for
remanufacturing process planning and scheduling,» Applied Soft Computing, p. 521–532,
2015.
[41] G. Mouzon, M. Yildrim e J. Twomey, «Operational methods for minimization of energy
consumption of manufacturing equipment,» International Journal of Production Research, p.
4247–4271, 2007.
[42] N. Frigerio e A. Matta, «Energy Saving Policies for a Machine Tool with Warm-Up, Stochastic
Arrivals and Buffer Information,» in EEE International Conference on Automation Science
and Engineering , taipei, 2014.
[43] N. Frigerio e A. Matta, «Analysis of an Energy Oriented Switching Control of Production
Lines,» in The 22nd CIRP conference on Life Cycle Engineering
www.elsevier.com/locate/procedia, 2015.
[44] E. A. Lee, Cyber Physical Systems: Design Challenges, Berkeley, 2008, p. 1.
[45] H.-A. Kao, W. Jin, D. Siegel e J. Lee, «A Cyber Physical Interface for Automation Systems—
Methodology and Examples,» Machines, pp. 93-106, 2015.
[46] F. Vaccari, A Study of the Energy Behaviours of a Manufacturig System, Milano, Mi, 2012.
[47] I. G. Barletta, Una Metodologia Cross View di Sviluppo di Key Performance Indicator di
Efficienza Energetica, 2012.
[48] D. Milanato e R. Pinto, Modellazione dei Sistemi Produttivi, vol. 1, Bologna, Bo: Pitagora
Editrice , 2006, pp. 1-16.
[49] G. May, B. Stahl, M. Taisch e V. Prabhu, «Multi-objective genetic algorithm for energy
143
efficient job shop scheduling,» International Journal of Production Research , gennaio 2015.
[50] G. Mouzon, M. Yildrim e J. Twomey, «Operational methods for minimization of energy
consumption of manufacturing equipment,» International Journal of Production Research,
2007.
[51] J. Heilala, S. Vatanen, H. Tonteri, J. Montonen, S. Lind, B. Johansson e J. Stahre, «Simulation-
based in manufacturing system design,» in Proceedings Winter Simulation Conference, 2008.
[52] J. Heilala, S. Vatanen, H. Tonteri, J. Montonen, S. Lind, B. Johansson e J. Stahre, «Simulation-
based sustainable manufacturing system design,» in Proceedings Winter Simulation
Conference.
[53] M. Macchi e S. Terzi, Modellazione dei Sistemi Produttivi, vol. 2, Bologna, Bo: Pitagora
Editrice, 2009.
[54] M. Macchi e S. Terzi , Modellazione dei Sistemi Produttivi, vol. 2, Bologna, Bo: Pitagora
Editrice, 2009, pp. 115-116.
[55] M. Macchi e S. Terzi, Modellazione dei Sistemi Produttivi, vol. 2, Bologna, Bo: Pitagora
Editrice, 2009, pp. 116-117.
[56] M. Macchi e S. Terzi , Modellazione dei Sistemi Produttivi, vol. 2, Bologna, Bo: Pitagora
Editrice, 2009, pp. 151-153.
[57] «Voce: Ciclo di Deming,» 4 gennaio 2016. [Online]. Available:
https://it.wikipedia.org/wiki/Ciclo_di_Deming. [Consultato il giorno 15 marzo 2016].
[58] A. Haıt e C. Artigues, «Scheduling Parallel Production Lines With Energy Costs,» The 13th
IFAC Symposium on Information Control Problems in Manufacturing , June 2009.
[59] W. Lin, D. Yu, C. Zhang , X. Liu, S. Zhang, Y. Tian, S. Liu e Z. Xie, «A multi-objective
teaching-learning-based optimization algorithm to scheduling in turning processes for
minimizing makespan and carbon footprint,» Journal of Cleaner Production, pp. 337-347,
2015.

144

ANNEXES
Annex 1: Experiments

Below we are going to show tables which summarize the results of the experiments we have carried
out, each for a different combination of ProcTime and TT values.
Starting from the left of the table it reads: the processing times of the machines in the Stages A, B
and C; the flow times of the six jobs typologies (Entity 1, Entity 2, Entity 3, Entity 4, Entity 5 and
Entity 6); the machines (SingleProc1, SingleProc2, SingleProc3, SingleProc4, SingleProc5 and
SingleProc6) saturation; for the Manzone Nervi 1 policy and the Manzone Nervi 2 policy the
standby durations are indicated in the same columns but in different rows; the standby duration
average and the saturation average; the number of the standby times; the makespan; total KWh
consumed, operational, working and standby energy consumed by each machine in each simulation
run; the total consumption; the percentage of energy saving compared to the base case; the
percentage of idle energy saving compared to the base case. Before showing the tables we have
specified the processing time of the machines and the threshold time we have set for the
simulations. For example ProcTime=(00:01:30-00:01:30-00:01:30) it means that the processing
time in equal to 1 minute and 30 seconds in the Stage A, 1 minute and 30 seconds in the Stage B
and 1 minute and 30 seconds in the Stage C.
145
A.1.1 ProcTime=(00:01:30-00:01:30-00:01:30), TT=00:00:30
146
A.1.2 ProcTime=(00:00:30-00:01:30-00:02:30), TT=00:00:30

147

148
A.1.3 ProcTime=(00:01:40-00:02:20-00:03:10), TT=00:00:30

149
A.1.4 ProcTime=(00:00:30-00:01:30-00:04:30), TT=00:00:30
150
151
A.1.5 ProcTime=(00:01:30-00:01:30-00:01:30), TT=00:01:00
152
A.1.6 ProcTime=(00:00:30-00:01:30-00:02:30), TT=00:01:00
153

154

A.1.7 ProcTime=(00:01:40-00:02:20-00:03:10), TT=00:01:00

155

A.1.8 ProcTime=(00:00:30-00:01:30-00:04:30), TT=00:01:00

156

157
A.1.9 ProcTime=(00:01:30-00:01:30-00:01:30), TT=00:01:30

158

A.1.10 ProcTime=(00:00:30-00:01:30-00:02:30), TT=00:01:30

159

160
A.1.11 ProcTime=(00:01:40-00:02:20-00:03:10), TT=00:01:30

161
A.1.12 ProcTime=(00:00:30-00:01:30-00:04:30), TT=00:01:30

162

A.1.13 ProcTime=(00:01:30-00:01:30-00:01:30), TT=00:02:00
163
164
A.1.14 ProcTime=(00:00:30-00:01:30-00:02:30), TT=00:02:00
165
A.1.15 ProcTime=(00:01:40-00:02:20-00:03:10), TT=00:02:00
166
A.1.16 ProcTime=(00:00:30-00:01:30-00:04:30), TT=00:02:00
167
168
A.1.17 ProcTime=(00:01:40-00:02:20-00:03:10), IAT=00:02:00, TT=00:03:00, TT=00:04:30,
TT=00:05:00

TT=00:10:00
A.1.19 ProcTime=(00:01:40-00:02:20-00:03:10), IAT=00:02:00, TT=00:12:00
169
TT=00:05:00

TT=00:10:00
A.1.22 ProcTime=(00:00:30-00:01:30-00:04:30), IAT=00:02:00, TT=00:12:00
170
TT=00:05:00

A.1.24 ProcTime=(00:00:30-00:01:30-00:04:30), IAT=00:00:30, TT=00:06:00

171
Annex 2: Code
In this annex we are going to show all the codes we had to write to let the simulator work according
to our conceptual models.
In all the cases we have written the same source-exit control because with this method the input
reads the table Sequenza and TableFile and sends all the jobs to the right stages according to their
paths.
In paragraphs 2.1.2, 2.1.3 and 2.1.4 we have written three Methods for the base case to allows the
machines to send the jobs to the right stage after they have worked them.
In paragraphs 2.2 and 2.3 there are all the codes written for the Manzone Nervi 1 policy and the
Manzone Nervi 2 policy respectively. Each stage has a code for both phases of the policies: first for
the routing phase and then the decisional phase on a machine energy state.

A.2.1 BASE CASE
A.2.1.1 Source-exit control
Is NextMachine : object;
do
if root.Sequenza[1,@.name][1,@.Op+1]=void then
@.move(root.drain);
else NextMachine := str_to_obj(root.Sequenza[1,@.name][1,@.Op+1]);
@.move(NextMachine);
end;
end;
A.2.1.2 Stage A-exit control
SingleProc1-exit control
do @.Op := @.Op+1;
@.move(root.drain);
else NextMachine :=str_to_obj(root.Sequenza[1,@.name][1,@.Op+1]);
end;
end;
Do @.Op := @.Op+1;
If root.Sequenza[1,@.name][1,@.Op+1]=void then
@.move(root.drain);
end;
end;
A.2.1.3 Stage B-exit control
172
Do @.Op := @.Op+1;
@.move(root.drain);
end;
end;
Do @.Op := @.Op+1;
@.move(root.drain);
end;
end;
A.2.1.4 Stage C-exit control
Do @.Op := @.Op+1;
@.move(root.drain);
end;
end;
Do @.Op := @.Op+1;
@.move(root.drain);
end;
end;
A.2.2 THE MANZONE NERVI 1 POLICY

do pezzi:=pezzi+1;
@.move(root.drain);
end;
end;
A.2.2.2 Stage A- routing phase and exit control

Buffer1-Exit control
Is target: object;
do
173
if Buffer11.Empty and SingleProc1.EnergyCurrentState="Operational" and
SingleProc2.EnergyCurrentState="Operational" and pezzi<=10 then
target:=SingleProc1;
elseif Buffer11.Empty and SingleProc1.EnergyCurrentState="Operational" and
SingleProc2.EnergyCurrentState:="Standby";
elseif Buffer11.Empty=false and SingleProc1.EnergyCurrentState="Operational" and
SingleProc2.EnergyCurrentState="Operational" then
elseif SingleProc1.EnergyCurrentState= "Operational" and
SingleProc2.EnergyCurrentState="Working" then
elseif SingleProc1.EnergyCurrentState= "Working" and
SingleProc2.EnergyCurrentState="Working" and
SingleProc1.cont.remainingProcTime<SingleProc2.cont.remainingProcTime then
elseif SingleProc1.EnergyCurrentState="Operational" and SingleProc2.EnergyCurrentState=
"Standby" then
elseif SingleProc1.EnergyCurrentState="Working" and SingleProc2.EnergyCurrentState="Standby"
and SingleProc1.cont.remainingProcTime <= TT then
elseif SingleProc1.EnergyCurrentState= "Standby" and SingleProc2.EnergyCurrentState=
"Standby" then
SingleProc1.EnergyCurrentState:="Operational";
StandbySingleProc1:=StandbySingleProc1+1;
and SingleProc1.cont.remainingProcTime > TT then
elseif SingleProc1.EnergyCurrentState="Standby" and SingleProc2.EnergyCurrentState="Working"
else target:=SingleProc2;
end;
if target/=VOID then
@.move(target);
else
@.move;
end;
end;
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
do @.Op := @.Op+1;
@.move(root.drain);
end;
174
if Buffer1.full and Buffer11.Empty and SingleProc2.EnergyCurrentState="Working" and
SingleProc2.cont.remainingProcTime=0 then
elseif Buffer1.empty and Buffer11.empty=false then
elseif Buffer1.empty and (SingleProc3.EnergyCurrentState="Working" and
SingleProc3.cont.remainingProcTime<=TT and (SingleProc3.cont.name="Entity3" or
SingleProc3.cont.name="Entity5")) and ((SingleProc4.EnergyCurrentState="Working" and
SingleProc4.cont.remainingProcTime>TT) or SingleProc4.empty) and
((SingleProc5.EnergyCurrentState="Working" and SingleProc5.cont.remainingProcTime>TT) or
SingleProc5.empty) and ((SingleProc6.EnergyCurrentState="Working" and
(SingleProc2.EnergyCurrentState="Operational" or (SingleProc2.EnergyCurrentState="Working" and
SingleProc2.cont.remainingProcTime<=TT)) then
elseif Buffer1.empty and ((SingleProc3.EnergyCurrentState="Working" and
(SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime<=TT and
(SingleProc4.cont.name="Entity3" or SingleProc4.cont.name="Entity5")) and
((SingleProc5.EnergyCurrentState="Working" and SingleProc5.cont.remainingProcTime>TT)
or SingleProc5.empty) and ((SingleProc6.EnergyCurrentState="Working" and
SingleProc4.empty) and (SingleProc5.EnergyCurrentState="Working" and
SingleProc6.cont.remainingProcTime<=TT and ((SingleProc6.cont.name="Entity2" or
SingleProc6.cont.name="Entity6") or SingleProc6.cont.name="Entity6")) and
SingleProc5.empty) and (SingleProc2.EnergyCurrentState="Operational" or
(SingleProc2.EnergyCurrentState="Working" and SingleProc2.cont.remainingProcTime<=TT)) then
Elseif Buffer1.empty and (SingleProc3.empty or (SingleProc3.EnergyCurrentState="Working" and
SingleProc3.cont.remainingProcTime>TT) or (SingleProc3.EnergyCurrentState="Working" and
SingleProc3.cont.name="Entity4") or (SingleProc3.cont.name="Entity2" or
SingleProc3.cont.name="Entity6")))) and (SingleProc4.empty or
(SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime>TT) or
((SingleProc4.cont.name="Entity1" or SingleProc4.cont.name="Entity4") or
(SingleProc4.cont.name="Entity2" or SingleProc4.cont.name="Entity6")))) and (SingleProc5.empty
or (SingleProc5.EnergyCurrentState="Working" and SingleProc5.cont.remainingProcTime>TT) or
(SingleProc6.cont.name="Entity3" or SingleProc6.cont.name="Entity5")))) then
175
else SingleProc1.EnergyCurrentState:="Operational";
end;
end;
SingleProc1-standby duration
is
do while (true) loop
if SingleProc1.EnergyCurrentState="Standby" then
DurationStandby1:=DurationStandby1+1;
Else DurationStandby1:=DurationStandby1;
end;
wait (1);
end;
end;
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
Do @.Op := @.Op+1;
@.move(root.drain);
end;

elseif Buffer1.Empty and (SingleProc3.EnergyCurrentState="Working" and
SingleProc4.cont.remainingProcTime>TT) or SingleProc4.Empty) and
SingleProc5.Empty) and ((SingleProc6.EnergyCurrentState="Working" and
(SingleProc1.EnergyCurrentState="Operational" or (SingleProc1.EnergyCurrentState="Working"
and SingleProc1.cont.remainingProcTime<=TT)) then
elseif Buffer1.Empty and (SingleProc3.Empty or (SingleProc3.EnergyCurrentState="Working" and
SingleProc3.cont.remainingProcTime>TT) ) and (SingleProc4.EnergyCurrentState="Working" and
SingleProc6.Empty) and (SingleProc1.EnergyCurrentState="Operational" or
SingleProc3.cont.remainingProcTime>TT) ) and ((SingleProc4.EnergyCurrentState="Working" and
176
SingleProc3.cont.remainingProcTime>TT)) and (SingleProc4.Empty or
(SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime>TT) ) and
(SingleProc6.cont.name="Entity2" or SingleProc6.cont.name="Entity6")) and (SingleProc5.Empty or
(SingleProc5.EnergyCurrentState="Working" and SingleProc5.cont.remainingProcTime>TT and
(SingleProc5.cont.name="Entity3" or SingleProc5.cont.name="Entity5")))) and
SingleProc4.EnergyCurrentState="Operational" or (SingleProc4.EnergyCurrentState="Working" and
SingleProc4.cont.name="Entity6")))) and (SingleProc5.Empty or
(SingleProc5.cont.name="Entity3" or SingleProc5.cont.name="Entity5")))) and (SingleProc6.Empty
end;
end;
is
end;
wait (1);
end;
end;
A.2.2.3 Stage B- routing phase and exit control

Buffer2-exit control
Is target: object;
do
SingleProc2.EnergyCurrentState="Operational" and pezzi>5 then
177
elseif SingleProc3.EnergyCurrentState= "Working" and SingleProc4.EnergyCurrentState=
"Working" and SingleProc3.cont.remainingProcTime<SingleProc4.cont.remainingProcTime then
"Standby" then
elseif SingleProc3.EnergyCurrentState= "Standby" and
SingleProc4.EnergyCurrentState="Standby" then
end;
@.move(target);
else @.move;
end;
end;
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
Do @.Op := @.Op+1;
@.move(root.drain);
end;
SingleProc1.cont.name="Entity6") ) and ((SingleProc2.EnergyCurrentState="Working" and
178
SingleProc1.cont.remainingProcTime<=60 and ((SingleProc1.cont.name="Entity2" or
(SingleProc6.EnergyCurrentState="Working" and SingleProc6.cont.remainingProcTime<=60 and
end;
end;
is
179
else
DurationStandby3:=DurationStandby3;
end;
wait (1);
end;
end;
is
NextMachine : object;
Entity1:string;
Entity2:string;
Entity3:string;
do
@.Op := @.Op+1;
@.move(root.drain);
end;

SingleProc1.cont.name="Entity6") ) and ((SingleProc2.EnergyCurrentState="Working" and
SingleProc2.cont.name="Entity1") and ((SingleProc5.EnergyCurrentState="Working" and
180
elseif Buffer2.empty and (SingleProc1.empty or (SingleProc1.EnergyCurrentState="Working" and
SingleProc1.cont.remainingProcTime>60) or (SingleProc1.EnergyCurrentState="Working" and
SingleProc1.cont.remainingProcTime<=60 and ((SingleProc1.cont.name="Entity2" or
(SingleProc2.EnergyCurrentState="Working" and SingleProc2.cont.remainingProcTime>60) or
SingleProc5.cont.name="Entity2"))) and (SingleProc6.empty or
Else SingleProc4.EnergyCurrentState:="Operational";
end;
end;
is
end;
wait (1);
end;
end;
A.2.2.4 Stage C- routing phase and exit control

Buffer 3-exit control
Is target: object;
do
181
elseif SingleProc5.EnergyCurrentState= "Working" and
SingleProc5.cont.remainingProcTime<SingleProc6.cont.remainingProcTime then
"Standby" then
elseif SingleProc5.EnergyCurrentState= "Standby" and SingleProc6.EnergyCurrentState=
"Standby" then
end;
@.move(target);
else
@.move;
end;
end;
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
do @.Op := @.Op+1;
@.move(root.drain);
end;
182
SingleProc3.cont.name="Entity6")))) and (SingleProc4.empty
or(SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime>TT) or
end;
end;
is
183
end;
wait (1);
end;
end;
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
do @.Op := @.Op+1;
@.move(root.drain);
end;
184
(SingleProc5.EnergyCurrentState="Working" and SingleProc5.cont.remainingProcTime<=TT))
then
(SingleProc1.EnergyCurrentState="Working" andSingleProc1.cont.remainingProcTime<=TT and
end;
end;
is
end;
wait (1);
end;
end;
A.2.3 THE MANZONE NERVI 2 POLICY

do pezzi:=pezzi+1;
@.move(root.drain);
end;
end;
A.2.3.2 Stage A- routing phase and exit control
Buffer1-Exit control
Is target: object;
Do
if Buffer1.full and Buffer2.Empty and Buffer3.Empty and Buffer11.Empty and
Buffer22.Empty and Buffer33.Empty and
SingleProc1.EnergyCurrentState="Standby" and SingleProc2.EnergyCurrentState=
185
"Standby" and SingleProc3.EnergyCurrentState="Standby" and
SingleProc4.EnergyCurrentState= "Standby" and
elseif Singleproc1.EnergyCurrentState="Standby" and SingleProc2.pause=true and
Buffer11.Empty then
waituntil (Buffer11.Empty=false or SingleProc2.pause=false) prio 1;
Buffer11.Empty then
elseif SingleProc1.pause=true and (SingleProc2.EnergyCurrentState="Working" or
SingleProc2.EnergyCurrentState="Operational") then
elseif Buffer11.Empty=false and SingleProc1.pause=true and
SingleProc1.EnergyCurrentState="Operational" ) then
"Working" and SingleProc1.cont.remainingProcTime<SingleProc2.cont.remainingProcTime
then
"Standby" then
186
end;
@.move(target);
else @.move;
end;
end;
is
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
Do @.Op := @.Op+1;
@.move(root.drain);
end;
if Buffer1.Empty and Buffer11.Empty and Buffer3.Empty and (Buffer33.Empty or

Buffer33.cont.name="Entity3") and SingleProc3.EnergyCurrentState="Standby"
and SingleProc4.EnergyCurrentState="Standby" and SingleProc2.EnergyCurrentState="Standby"
and SingleProc6.EnergyCurrentState="Standby" and SingleProc5.EnergyCurrentState="Working"
and (SingleProc5.cont.name="Entity2" or SingleProc5.cont.name="Entity6") and
SingleProc5.cont.remainingProcTime<=TT then
SingleProc1.EnergyCurrentState:="Standby" ;
SingleProc3.cont.remainingProcTime>TT and (SingleProc3.cont.name="Entity3" or
SingleProc3.cont.name="Entity5")) or (SingleProc3.EnergyCurrentState="Working" and
(SingleProc3.cont.name="Entity2" or SingleProc3.cont.name="Entity6") ))) and SingleProc4.Empty
or (SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime>TT and
(SingleProc4.cont.name="Entity3" or SingleProc4.cont.name="Entity5")) or
(SingleProc4.EnergyCurrentState="Working" and ((SingleProc4.cont.name="Entity1" or
SingleProc4.cont.name="Entity6") ))) and (SingleProc5.Empty or
SingleProc6.cont.name="Entity5") ))) then
187
elseif Buffer1.full and Buffer11.Empty and SingleProc2.EnergyCurrentState="Working" and
elseif SingleProc2.EnergyCurrentState="Standby" and SingleProc3.EnergyCurrentState="Standby"
and SingleProc4.EnergyCurrentState="Standby" and SingleProc5.EnergyCurrentState="Standby" and
SingleProc6.EnergyCurrentState="Working" and SingleProc6.cont.remainingProcTime<=TT and
Buffer1.Empty and Buffer2.Empty and Buffer3.Empty and Buffer11.Empty then
elseif SingleProc3.EnergyCurrentState="Working" and SingleProc3.cont.remainingProcTime<=TT
and (SingleProc3.cont.name="Entity3" or SingleProc3.cont.name="Entity5") and
SingleProc5.EnergyCurrentState="Working" and ((SingleProc5.cont.remainingProcTime-
SingleProc1.ProcTime)>TT) and SingleProc5.cont.name=" Entity2" and
((SingleProc4.EnergyCurrentState= "Working" and ((SingleProc4.cont.name="Entity2" or
SingleProc4.cont.name="Entity4"))) or SingleProc4.Empty) and ((SingleProc6.EnergyCurrentState=
"Working" and ((SingleProc6.cont.name="Entity3" or SingleProc6.cont.name="Entity5") or
(SingleProc6.cont.name="Entity1" or SingleProc6.cont.name="Entity4"))) or SingleProc6.Empty) and
((Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6") or (Buffer2.cont.name="Entity1" or
Buffer2.cont.name="Entity4") or Buffer2.Empty) and Buffer1.Empty and
((Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4") or Buffer3.con.name= "Entity3" or
Buffer3.Empty) and (SingleProc2.EnergyCurrentState= "Working" or
SingleProc2.EnergyCurrentState= "Operational") then
SingleProc1.startPause(SingleProc5.cont.remainingProcTime-SingleProc1.ProcTime);
elseif SingleProc3.EnergyCurrentState= "Working" and SingleProc3.cont.remainingProcTime<=TT and
(SingleProc3.cont.name="Entity3" or SingleProc3.cont.name="Entity5") and
SingleProc5.EnergyCurrentState= "Working" and ((SingleProc5.cont.remainingProcTime-
SingleProc1.ProcTime)>TT) and (SingleProc5.cont.name="Entity2" or
SingleProc5.cont.name="Entity6") and ((SingleProc4.EnergyCurrentState= "Working" and
SingleProc6.cont.name="Entity4"))) or SingleProc6.Empty) and (Buffer2.Empty or
(Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6") or (Buffer2.cont.name="Entity1" or
Buffer2.cont.name="Entity4") ) and Buffer1.Empty and (Buffer3.Empty or
Buffer3.cont.name="Entity5") ) and SingleProc2.EnergyCurrentState= "Standby" then
SingleProc1.pause:=true;
Waituntil SingleProc2.EnergyCurrentState="Operational" prio 1;
SingleProc1.pause:=false;
Elseif SingleProc3.EnergyCurrentState= "Working" and SingleProc3.cont.remainingProcTime<=TT and

SingleProc5.EnergyCurrentState= "Working" and ((SingleProc5.cont.name="Entity3" or
SingleProc5.cont.name="Entity4"))and ((SingleProc5.cont.remainingProcTime+
SingleProc5.ProcTime-SingleProc1.ProcTime)>TT) and ((SingleProc4.EnergyCurrentState=
(((SingleProc6.EnergyCurrentState= "Working" and ((SingleProc6.cont.name="Entity3" or
SingleProc6.cont.name="Entity5")or (SingleProc6.cont.name="Entity1" or
SingleProc6.cont.name="Entity4")))and (SingleProc5.cont.remainingProcTime<=
SingleProc6.cont.remainingProcTime)) or SingleProc6.Empty) and (Buffer2.Empty or
Buffer2.cont.name="Entity4")) and Buffer1.Empty and (Buffer3.Empty or
(Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6")) and
(SingleProc2.EnergyCurrentState= "Working" or SingleProc2.EnergyCurrentState= "Operational")
thenSingleProc1.startPause(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
SingleProc1.ProcTime);
188
SingleProc6.cont.name="Entity4")))and(SingleProc5.cont.remainingProcTime<=
SingleProc2.EnergyCurrentState= "Standby" then
SingleProc6.cont.name="Entity4")))and(SingleProc5.cont.remainingProcTime>SingleProc6.cont.rem
ainingProcTime)) or SingleProc6.Empty) and (Buffer2.Empty or (Buffer2.cont.name="Entity2" or
Buffer2.cont.name="Entity6") or (Buffer2.cont.name="Entity1" or Buffer2.cont.name="Entity4") )
and Buffer1.Empty and (Buffer3.Empty or (Buffer3.cont.name="Entity1" or
Buffer3.cont.name="Entity4") or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5"))
and (SingleProc2.EnergyCurrentState= "Working" or SingleProc2.EnergyCurrentState=
"Operational") then
SingleProc1.startPause(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
and SingleProc2.EnergyCurrentState= "Standby" then

189
SingleProc6.ProcTime-SingleProc1.ProcTime)>TT) and
(SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime) and (Buffer2.Empty or
then SingleProc1.startPause(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-
Buffer2.cont.name="Entity4") ) and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or
and SingleProc2.EnergyCurrentState= "Standby" then SingleProc1.pause:=true;
SingleProc1.ProcTime)>TT) and ((SingleProc4.EnergyCurrentState= "Working" and
Buffer3.cont.name="Entity5") ) and (SingleProc2.EnergyCurrentState= "Working" or
(SingleProc4.cont.name="Entity1" or SingleProc4.cont.name="Entity4"))) or SingleProc4.Empty)
and ((SingleProc5.EnergyCurrentState= "Working" and ((SingleProc5.cont.name="Entity3" or
Buffer2.cont.name="Entity4") ) and Buffer1.Empty and ( Buffer3.Empty or Buffer3.Empty or
190
"Operational") then
191

(SingleProc3.cont.remainingProcTime+ SingleProc3.ProcTime-SingleProc1.ProcTime)>TT and
192
SingleProc4.cont.name="Entity5")) and
(SingleProc3.cont.remainingProcTime<=SingleProc4.cont.remainingProcTime)) or
SingleProc4.Empty) and (Buffer2.Empty or (Buffer2.cont.name="Entity3" or
SingleProc1.startPause(SingleProc3.cont.remainingProcTime+ SingleProc3.ProcTime-
and((SingleProc4.EnergyCurrentState= "Working" and ((SingleProc4.cont.name="Entity2" or
SingleProc4.cont.name="Entity6")) and (SingleProc4.cont.remainingProcTime+
SingleProc4.ProcTime-SingleProc1.ProcTime)>TT and
(SingleProc4.cont.remainingProcTime<=SingleProc3.cont.remainingProcTime) and
(Buffer2.Empty or (Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5")) and
Buffer1.Empty and (Buffer3.Empty or (Buffer3.cont.name="Entity1" or
"Operational") then SingleProc1.startPause(SingleProc4.cont.remainingProcTime+
SingleProc4.ProcTime-SingleProc1.ProcTime);
193
(SingleProc4.cont.remainingProcTime<SingleProc3.cont.remainingProcTime) and
(Buffer2.Empty or (Buffer2.cont.name="Entity1" or Buffer2.cont.name="Entity4") or
(Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6")) and Buffer1.Empty and
(Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5") ) and
then
194
SingleProc6.cont.name="Entity4"))) or SingleProc6.Empty)and (Buffer2.Empty or
SingleProc5.EnergyCurrentState= "Working" and
((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-SingleProc1.ProcTime)>TT) and
(SingleProc5.cont.name="Entity3" or SingleProc5.cont.name="Entity5") ) and
SingleProc3.cont.name="Entity4"))) or SingleProc3.Empty) and (((SingleProc6.EnergyCurrentState=
(SingleProc6.cont.name="Entity1" or SingleProc6.cont.name="Entity4"))) and
(SingleProc5.cont.remainingProcTime<= SingleProc6.cont.remainingProcTime))or
Buffer3.cont.name="Entity6")) and (SingleProc2.EnergyCurrentState= "Working" or
SingleProc3.cont.name="Entity4"))) or SingleProc3.Empty) and (SingleProc6.Empty
or((SingleProc6.EnergyCurrentState= "Working" and ((SingleProc6.cont.name="Entity3" or
SingleProc6.cont.name="Entity4"))) and (SingleProc5.cont.remainingProcTime<=
SingleProc6.cont.remainingProcTime))) and (Buffer2.Empty or (Buffer2.cont.name="Entity2" or
Buffer3.cont.name="Entity6")) and SingleProc2.EnergyCurrentState= "Standby" then
195
(SingleProc6.cont.name="Entity3" or SingleProc6.cont.name="Entity5") )
SingleProc3.cont.name="Entity4"))) or SingleProc3.Empty) and
(SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime) and(Buffer2.Empty or

(SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime) and (Buffer2.Empty
or (Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6") or (Buffer2.cont.name="Entity1"
or Buffer2.cont.name="Entity4") ) and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or
"Operational") then
196
or Buffer2.cont.name="Entity4")) and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or
and SingleProc2.pause=true then
print "bis";
Buffer2.cont.name="Entity4")) and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or
and SingleProc2.EnergyCurrentState="Standby" then
print "bisbis";
SingleProc5.cont.name="Entity4"))) or SingleProc5.Empty)and ( Buffer2.Empty or
Buffer2.cont.name="Entity4") ) and Buffer1.Empty and ( Buffer3.Empty or
197

(SingleProc6.cont.name="Entity1" or SingleProc6.cont.name="Entity4"))and
(SingleProc5.cont.name="Entity1" or SingleProc5.cont.name="Entity4")))and
(SingleProc6.cont.remainingProcTime<= SingleProc5.cont.remainingProcTime)) or
SingleProc5.Empty)and (Buffer2.Empty or (Buffer2.cont.name="Entity2" or

198
SingleProc3.cont.name="Entity4"))) or SingleProc3.Empty) and SingleProc5.EnergyCurrentState=
(SingleProc6.cont.remainingProcTime<= SingleProc5.cont.remainingProcTime)and
(Buffer2.cont.name="Entity1" or Buffer2.cont.name="Entity4") ) and Buffer1.Empty and
((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6")) and


199

((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-SingleProc1.ProcTime)>TT)
and(((SingleProc3.EnergyCurrentState= "Working" and ((SingleProc3.cont.name="Entity2" or
SingleProc3.cont.remainingProcTime)) or SingleProc3.Empty) and
"Operational") then


SingleProc3.cont.name="Entity4"))) and (SingleProc4.cont.remainingProcTime>
SingleProc3.cont.remainingProcTime)) and
200
"Operational") then

SingleProc3.cont.name="Entity4"))) and
(SingleProc4.cont.remainingProcTime<=SingleProc3.cont.remainingProcTime)) and
"Operational") then
201
SingleProc3.cont.name="Entity5"))) and ((SingleProc3.cont.remainingProcTime-
SingleProc1.ProcTime)>TT)) and ((SingleProc6.EnergyCurrentState= "Working" and
202
SingleProc1.ProcTime)>TT))and ((SingleProc6.EnergyCurrentState= "Working" and
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime-SingleProc1.ProcTime)>TT))and
(SingleProc4.cont.name="Entity1" or
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime-SingleProc1.ProcTime)>TT)) and
SingleProc4.Empty) and ( Buffer2.Empty or (Buffer2.cont.name="Entity3" or

203
(SingleProc4.cont.remainingProcTime< SingleProc3.cont.remainingProcTime)) and
((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-
SingleProc1.ProcTime)>TT)and(SingleProc4.cont.remainingProcTime<
SingleProc3.cont.remainingProcTime))and ((SingleProc6.EnergyCurrentState= "Working" and
SingleProc4.cont.name="Entity6"))) and (SingleProc4.cont.remainingProcTime<
SingleProc3.cont.remainingProcTime)) and((SingleProc6.EnergyCurrentState= "Working" and
SingleProc4.cont.name="Entity6"))) and(SingleProc4.cont.remainingProcTime<
SingleProc3.cont.remainingProcTime)) and ((SingleProc6.EnergyCurrentState= "Working" and
204

SingleProc1.ProcTime)>TT))and (SingleProc3.EnergyCurrentState= "Working" and
Buffer3.cont.name="Entity4") or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5") or
SingleProc6.cont.name="Entity4"))) or SingleProc6.Empty) and ((Buffer2.cont.name="Entity1" or
Buffer2.Empty) and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or
Buffer3.Empty) and SingleProc2.EnergyCurrentState= "Standby" then

SingleProc3.cont.remainingProcTime)) or SingleProc3.Empty)and
205
(SingleProc4.cont.remainingProcTime>SingleProc3.cont.remainingProcTime) and
206

(SingleProc3.cont.remainingProcTime<=SingleProc4.cont.remainingProcTime))or
SingleProc3.Empty) and ((SingleProc6.EnergyCurrentState= "Working" and
((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-SingleProc1.ProcTime)>TT)and
(SingleProc6.cont.remainingProcTime>SingleProc5.cont.remainingProcTime)) and
207
(SingleProc6.cont.remainingProcTime<SingleProc5.cont.remainingProcTime)) and
208
elseif SingleProc3.EnergyCurrentState= "Working" and SingleProc6.EnergyCurrentState= "Working" and
SingleProc6.cont.name="Entity6") and ((SingleProc3.cont.remainingProcTime-
(SingleProc4.cont.name="Entity1" or SingleProc4.cont.name="Entity4"))) or SingleProc4.Empty)and
Buffer3.cont.name="Entity5") or Buffer3.Empty) and (SingleProc2.EnergyCurrentState= "Working"
or SingleProc2.EnergyCurrentState= "Operational") then
SingleProc1.ProcTime)>TT)and ((SingleProc4.EnergyCurrentState= "Working" and
209
Buffer3.cont.name="Entity5") or Buffer3.Empty) and SingleProc2.EnergyCurrentState= "Standby"
then

SingleProc6.cont.name="Entity6") and SingleProc3.EnergyCurrentState= "Working" and
SingleProc4.cont.remainingProcTime))or SingleProc4.Empty)and ((SingleProc5.EnergyCurrentState=
"Operational") then
SingleProc4.cont.remainingProcTime))or SingleProc4.Empty)and

SingleProc3.cont.remainingProcTime))and
210

SingleProc4.cont.name="Entity4")))or SingleProc4.Empty)and ((SingleProc5.EnergyCurrentState=
(Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6")) and Buffer1.Empty and (
Buffer3.Empty or (Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4") or
SingleProc4.cont.name="Entity4")))or SingleProc4.Empty) and ((SingleProc5.EnergyCurrentState=
211
SingleProc4.cont.name="Entity5")) and ((SingleProc4.cont.remainingProcTime-
(SingleProc3.cont.name="Entity1" or SingleProc3.cont.name="Entity4")))or SingleProc3.Empty)and
(SingleProc3.cont.name="Entity1" or SingleProc3.cont.name="Entity4")))or SingleProc3.Empty) and

SingleProc3.cont.remainingProcTime))or SingleProc3.Empty) and
212
SingleProc3.cont.name="Entity4")))and
(SingleProc4.cont.remainingProcTime>SingleProc3.cont.remainingProcTime))and
then
SingleProc3.cont.name="Entity4")) and (SingleProc3.cont.remainingProcTime <=
213
Buffer2.cont.name="Entity6")) and Buffer1.Empty and ( Buffer3.Empty or
SingleProc2.EnergyCurrentState= "Operational")
214
(SingleProc5.EnergyCurrentState= "Working" and ((SingleProc5.cont.name="Entity3" or
(SingleProc5.cont.remainingProcTime<= SingleProc6.cont.remainingProcTime) and
215
(Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6")or Buffer2.Empty) and Buffer1.Empty
and ((Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4") or
SingleProc4.EnergyCurrentState= "Working" and SingleProc4.cont.remainingProcTime<=TT and
SingleProc1.ProcTime)> TT) and ((SingleProc6.EnergyCurrentState="Working" and
(SingleProc2.EnergyCurrentState= "Operational" or (SingleProc2.EnergyCurrentState="Working"
and SingleProc2.cont.remainingProcTime<=TT))and (Buffer1.Empty) and (Buffer2.Empty or
Buffer2.cont.name="Entity6") ) and (Buffer3.Empty or (Buffer3.cont.name="Entity1" or
Buffer3.Empty) then SingleProc1.startPause(SingleProc5.cont.remainingProcTime-
((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-SingleProc1.ProcTime)> TT) and
((SingleProc6.EnergyCurrentState="Working" and ((SingleProc6.cont.name="Entity2" or
SingleProc6.cont.name="Entity4"))and (SingleProc5.cont.remainingProcTime<=
and SingleProc2.cont.remainingProcTime<=TT)) and (Buffer2.Empty or
(Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6")) then
216
SingleProc6.cont.remainingProcTime) and
((SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc1.ProcTime)> TT)and
and SingleProc2.cont.remainingProcTime<=TT))and (Buffer2.Empty or
SingleProc6.cont.name="Entity4"))) or SingleProc6.Empty) and (SingleProc2.EnergyCurrentState=
"Operational" or (SingleProc2.EnergyCurrentState="Working" and
SingleProc2.cont.remainingProcTime<=TT)) and (Buffer2.Empty or (Buffer2.cont.name="Entity2" or
Buffer2.Empty) and Buffer1.Empty and (Buffer3.Empty or (Buffer3.cont.name="Entity1" or
Buffer3.cont.name="Entity4") or Buffer3.con.name= "Entity3" or Buffer3.Empty) then
SingleProc6.EnergyCurrentState="Working" and ((SingleProc6.cont.name="Entity2" or
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4") or Buffer3.con.name= "Entity3" or
217
((SingleProc5.EnergyCurrentState="Working" and (SingleProc6.cont.remainingProcTime<=
SingleProc5.cont.remainingProcTime) and ((SingleProc5.cont.name="Entity1" or
SingleProc2.cont.remainingProcTime<=TT)) and ((Buffer2.cont.name="Entity2" or
Buffer3.cont.name="Entity6")) then
SingleProc5.cont.name="Entity5")) and SingleProc6.EnergyCurrentState="Working" and
(SingleProc6.cont.remainingProcTime> SingleProc5.cont.remainingProcTime) and
and SingleProc2.cont.remainingProcTime<=TT)) and ((Buffer2.cont.name="Entity2" or
(SingleProc4.cont.name="Entity3" or SingleProc4.cont.name="Entity5")and
218
Buffer3.cont.name="Entity4")or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5") or
Buffer3.Empty) then
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4")or (Buffer3.cont.name="Entity3" or
Buffer3.cont.name="Entity5") ) then
Buffer3.Empty) then
219
Buffer3.Empty) then
elseif SingleProc3.EnergyCurrentState="Working" and SingleProc3.cont.remainingProcTime<=TT and
and(SingleProc2.EnergyCurrentState="Operational" or (SingleProc2.EnergyCurrentState="Working"
Buffer3.Empty) thenSingleProc1.startPause(SingleProc4.cont.remainingProcTime-
SingleProc4.EnergyCurrentState="Working"
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-SingleProc1.ProcTime)> TT) and
Buffer3.Empty) then
(SingleProc4.cont.remainingProcTime>SingleProc3.cont.remainingProcTime)and
SingleProc6.cont.name="Entity5"))) or SingleProc6.Empty)
Buffer2.cont.name="Entity6") or Buffer2.Empty) and Buffer1.Empty and (Buffer3.Empty or
Buffer3.cont.name="Entity5") or Buffer3.Empty) then
220
SingleProc1.ProcTime)> TT)) and ((SingleProc4.EnergyCurrentState="Working" and
(SingleProc4.cont.name="Entity2" or SingleProc4.cont.name="Entity6"))) or SingleProc4.Empty )
((SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc1.ProcTime)> TT)) and
SingleProc4.cont.name="Entity6"))) or SingleProc4.Empty )
SingleProc1.startPause(SingleProc6.cont.remainingProcTime+SingeProc6.ProcTime-
SingleProc4.cont.remainingProcTime)) or SingleProc4.Empty ) and
SingleProc6.cont.name="Entity5"))) or SingleProc6.Empty ) and
221
Buffer3.Empty) then
SingleProc4.cont.name="Entity6"))and (SingleProc3.cont.remainingProcTime>
SingleProc4.cont.remainingProcTime))) and ((SingleProc6.EnergyCurrentState="Working" and
Buffer3.Empty) then
SingleProc6.cont.name="Entity5"))and
SingleProc6.Empty ) and ((SingleProc4.EnergyCurrentState="Working" and
and (SingleProc2.EnergyCurrentState="Operational" or (SingleProc2.EnergyCurrentState="Working"
Buffer3.cont.name="Entity6"))
thenSingleProc1.startPause(SingleProc5.cont.remainingProcTime+SingeProc5.ProcTime-
--
(SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime))) and
222
Buffer3.Empty) then
(SingleProc4.EnergyCurrentState="Working" and (SingleProc4.cont.name="Entity3" or
SingleProc4.cont.name="Entity5"))and ((SingleProc4.cont.remainingProcTime-
Buffer3.Empty) then
223
SingleProc1.ProcTime)> TT)and ((SingleProc4.EnergyCurrentState="Working" and
and(SingleProc2.EnergyCurrentState= "Operational" or (SingleProc2.EnergyCurrentState="Working"
SingleProc5.cont.name="Entity5")))and ((SingleProc5.cont.remainingProcTime+
SingleProc5.ProcTime-SingleProc1.ProcTime)> TT)and
(SingleProc5.cont.remainingProcTime<=SingleProc6.cont.remainingProcTime)and
SingleProc4.cont.name="Entity6"))) or SingleProc4.Empty ) and(SingleProc2.EnergyCurrentState=
Buffer3.cont.name="Entity6"))
SingleProc4.cont.name="Entity6"))) or SingleProc4.Empty ) and(SingleProc2.EnergyCurrentState=
Buffer2.cont.name="Entity4")or (Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6") )
((SingleProc3.cont.remainingProcTime+ SingleProc3.ProcTime-SingleProc1.ProcTime)> TT)and
SingleProc5.cont.name="Entity5"))) or SingleProc5.Empty ) and (SingleProc2.EnergyCurrentState=
224
SingleProc5.cont.name="Entity4") or SingleProc5.cont.name="Entity5")and
and (SingleProc2.EnergyCurrentState= "Operational" or
(SingleProc2.EnergyCurrentState="Working" and SingleProc2.cont.remainingProcTime<=TT)) and
(Buffer2.Empty or (Buffer2.cont.name="Entity1" or Buffer2.cont.name="Entity4") or (Buffer2.Empty
or Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6")) and Buffer1.Empty and
(Buffer3.Empty or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5") ) then
(SingleProc6.cont.remainingProcTime> SingleProc5.cont.remainingProcTime)) ) and
and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4") or
(Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5") or Buffer3.Empty) then
elseif (SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime<=TT and
SingleProc1.ProcTime)>TT) and ((SingleProc6.EnergyCurrentState="Working" and
225
(SingleProc3.EnergyCurrentState="Working" and( (SingleProc3.cont.name="Entity1" or
Buffer3.Empty) then
226
SingleProc1.startPause(SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime-
Buffer3.cont.name="Entity4")or Buffer3.Empty) then
SingleProc1.startPause(SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime-
(((SingleProc3.EnergyCurrentState="Working" and ((SingleProc3.cont.name="Entity1" or
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4")or Buffer3.Empty) then
227
Buffer3.cont.name="Entity5") or (Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4")or
Buffer3.Empty) then
Buffer3.cont.name="Entity5") )
SingleProc3.cont.name="Entity5")) and((SingleProc3.cont.remainingProcTime-
228
SingleProc3.cont.name="Entity6")) and((SingleProc3.cont.remainingProcTime
+SingleProc3.ProcTime-SingleProc1.ProcTime)>TT)and (SingleProc3.cont.remainingProcTime<=
SingleProc4.cont.remainingProcTime) and ((SingleProc5.EnergyCurrentState="Working" and
(Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5") ) then
+SingleProc3.ProcTime-SingleProc1.ProcTime)>TT) and (SingleProc3.cont.remainingProcTime>
Buffer3.Empty) then
+SingleProc5.ProcTime-SingleProc1.ProcTime)>TT) and (SingleProc5.cont.remainingProcTime<=
229
Buffer3.cont.name="Entity5") or Buffer3.Empty ) then
Buffer2.Empty ) and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or
Buffer3.Empty ) then
230
SingleProc1.ProcTime)>TT)) and ((SingleProc4.EnergyCurrentState="Working" and
231
((Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5")) and Buffer1.Empty and
Buffer3.Empty) then
(SingleProc3.cont.remainingProcTime>SingleProc4.cont.remainingProcTime))or SingleProc4.Empty)
Buffer3.Empty) then
232
(SingleProc4.EnergyCurrentState="Working" and ( (SingleProc4.cont.name="Entity1" or
SingleProc4.cont.name="Entity6"))) and((SingleProc4.cont.remainingProcTime
+SingleProc4.ProcTime-SingleProc1.ProcTime)>TT) and
Buffer3.Empty) then
233
Buffer3.Empty) then
Buffer3.cont.name="Entity6")) then SingleProc1.startPause(SingleProc5.cont.remainingProcTime +
Buffer3.Empty) then SingleProc1.startPause(SingleProc5.cont.remainingProcTime +
(SingleProc5.cont.remainingProcTime>=SingleProc6.cont.remainingProcTime) and
234
(SingleProc2.EnergyCurrentState="Operational" or (SingleProc2.EnergyCurrentState="Working"))
and ((Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5")) and Buffer1.Empty and
Buffer3.cont.name="Entity5") or Buffer3.Empty) and (SingleProc3.cont.remainingProcTime<=
SingleProc4.cont.remainingProcTime) then
SingleProc1.startPause(SingleProc3.cont.remainingProcTime + SingleProc3.ProcTime-
(SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty or (Buffer2.cont.name="Entity3"
or Buffer2.cont.name="Entity5")) and Buffer1.Empty and (Buffer3.Empty or
Buffer3.cont.name="Entity5") ) and (SingleProc3.cont.remainingProcTime<=
235
Buffer3.cont.name="Entity5") or Buffer3.Empty) and (SingleProc3.cont.remainingProcTime>
Buffer3.cont.name="Entity5")) and
(SingleProc3.cont.remainingProcTime>SingleProc4.cont.remainingProcTime) then
SingleProc1.ProcTime)>TT))and ((SingleProc6.EnergyCurrentState="Working" and
and (SingleProc2.EnergyCurrentState="Operational" or
(SingleProc2.EnergyCurrentState="Working")) and ((Buffer2.cont.name="Entity3" or
Buffer3.Empty) and (SingleProc3.cont.remainingProcTime<=SingleProc4.cont.remainingProcTime)
and (SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime<=
236
and
(SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime>SingleProc5.cont.remainingProcTime
) then SingleProc1.startPause(SingleProc5.cont.remainingProcTime-SingleProc1.ProcTime);
and (SingleProc2.EnergyCurrentState="Standby" ) and (Buffer2.Empty or
) then SingleProc1.startPause(SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime-
and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty or
(SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime<=SingleProc5.cont.remainingProcTim
e) then SingleProc1.startPause(SingleProc5.cont.remainingProcTime-SingleProc1.ProcTime);
(SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime<=
SingleProc5.cont.remainingProcTime+ SingleProc5.ProcTime) then
237
SingleProc6.cont.name="Entity5")))and (SingleProc5.cont.remainingProcTime>=
SingleProc6.cont.remainingProcTime)) and (SingleProc2.EnergyCurrentState="Operational" or
+ SingleProc5.ProcTime) then SingleProc1.startPause(SingleProc5.cont.remainingProcTime +
(SingleProc2.EnergyCurrentState="Operational" or
(SingleProc2.EnergyCurrentState="Working"))and ((Buffer2.cont.name="Entity3" or
Buffer3.Empty ) and (SingleProc3.cont.remainingProcTime<=SingleProc4.cont.remainingProcTime)
and
238
(SingleProc2.EnergyCurrentState="Standby") and ( Buffer2.Empty or (Buffer2.cont.name="Entity3"
SingleProc6.cont.name="Entity5")))and (SingleProc5.cont.remainingProcTime>
SingleProc6.cont.remainingProcTime))) and (SingleProc2.EnergyCurrentState="Standby") and
Buffer1.Empty and ((Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4") or
(Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5") or Buffer3.Empty) and
e+ SingleProc5.ProcTime) then SingleProc1.startPause(SingleProc5.cont.remainingProcTime +
239
(SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime)))and
and
and
240
and (SingleProc2.EnergyCurrentState="Standby")and (Buffer2.Empty or
SingleProc6.cont.name="Entity6") and
e+SingleProc6.ProcTime) then
241
SingleProc5.cont.remainingProcTime))) and (SingleProc2.EnergyCurrentState="Operational" or
and
+SingleProc6.ProcTime) then
and
242
(SingleProc2.EnergyCurrentState="Standby")and (Buffer2.Empty or(Buffer2.cont.name="Entity3" or
and
(SingleProc2.EnergyCurrentState="Standby")and (Buffer2.Empty or(Buffer2.cont.name="Entity3" or
243
SingleProc5.cont.remainingProcTime))) and (SingleProc2.EnergyCurrentState="Standby")and
Buffer3.cont.name="Entity4") or Buffer3.Empty or (Buffer3.cont.name="Entity3" or
Buffer3.cont.name="Entity5") ) and
Buffer3.cont.name="Entity5") or Buffer3.Empty) and
e) then SingleProc1.startPause(SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-
and
244
) then SingleProc1.startPause(SingleProc4.cont.remainingProcTime+SIngleProc4.ProcTime-
(SingleProc2.EnergyCurrentState="Standby")and (Buffer2.Empty or (Buffer2.cont.name="Entity3" or
and
SingleProc2.EnergyCurrentState="Working")and (Buffer2.Empty or (Buffer2.cont.name="Entity3" or
(SingleProc2.EnergyCurrentState="Operational" or SingleProc2.EnergyCurrentState="Working")and
245
Buffer3.cont.name="Entity5") or Buffer3.Empty ) and
SingleProc6.Empty) and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty or
246
and
247
and
and
248
and
and
249
and
(SingleProc2.EnergyCurrentState="Standby" ) and (Buffer2.Empty or (Buffer2.cont.name="Entity3"
250
(SingleProc2.EnergyCurrentState="Standby" ) and (Buffer2.Empty or (Buffer2.cont.name="Entity3"
and (SingleProc4.cont.remainingProcTime<=SingleProc3.cont.remainingProcTime) and
251
SingleProc5.cont.name="Entity6") )and ((SingleProc5.cont.remainingProcTime-
SingleProc1.ProcTime)>TT) and ((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
SingleProc1.ProcTime)>TT)and (((SingleProc6.EnergyCurrentState="Working" and
Buffer3.cont.name="Entity6") ) then SingleProc1.startPause(SingleProc5.cont.remainingProcTime-
(SingleProc5.cont.remainingProcTime<= SingleProc6.cont.remainingProcTime))) and
or Buffer2.cont.name="Entity6") or (Buffer2.cont.name="Entity1" or Buffer2.cont.name="Entity4") )
Buffer3.Empty or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5")) then
252
or Buffer2.cont.name="Entity6") or (Buffer2.cont.name="Entity1" or Buffer2.cont.name="Entity4")
or Buffer2.Empty) and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or
SingleProc1.ProcTime)>TT) and (SingleProc6.EnergyCurrentState="Working" and
(SingleProc6.cont.name="Entity2" or SingleProc6.cont.name="Entity6") )and
((SingleProc6.cont.remainingProcTime-SingleProc1.ProcTime)>TT)and
253
(SingleProc2.EnergyCurrentState="Standby") and ((Buffer2.cont.name="Entity2" or
then SingleProc1.startPause(SingleProc5.cont.remainingProcTime-SingleProc1.ProcTime);
Buffer1.Empty and ((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6")) then
and Buffer1.Empty and ((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6")) then
254
SingleProc1.ProcTime)>TT) and (((SingleProc5.EnergyCurrentState="Working" and
Buffer3.cont.name="Entity6")) then SingleProc1.startPause(SingleProc6.cont.remainingProcTime-
(SingleProc6.cont.remainingProcTime> SingleProc5.cont.remainingProcTime))) and
255
((Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4") or Buffer3.Empty or
(SingleProc2.EnergyCurrentState="Standby")and ((Buffer2.cont.name="Entity3" or
Buffer3.cont.name="Entity5")) then SingleProc1.startPause(SingleProc3.cont.remainingProcTime
+SingleProc3.ProcTime-SingleProc1.ProcTime);
SingleProc4.cont.name="Entity4") ))and
256
SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)and
SingleProc1.startPause(SingleProc4.cont.remainingProcTime +SingleProc4.ProcTime-
(SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime>
+SingleProc4.ProcTime)and (SingleProc2.EnergyCurrentState="Standby") and
257
(SingleProc4.Empty or ((SingleProc4.EnergyCurrentState="Working"
and((SingleProc4.cont.name="Entity2" or SingleProc4.cont.name="Entity6") or
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime)<=(
SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)) and
SingleProc6.cont.name="Entity5")) and (SingleProc5.cont.remainingProcTime<=
((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6")) then
((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-SingleProc1.ProcTime)>TT) and (
SingleProc4.Empty or ((SingleProc4.EnergyCurrentState="Working" and
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime)>(
(SingleProc3.cont.remainingProcTime<= SingleProc4.cont.remainingProcTime)))and
(SingleProc4.Empty or ((SingleProc4.EnergyCurrentState="Working" and
(SingleProc3.cont.remainingProcTime<= SingleProc4.cont.remainingProcTime))and
258
(SingleProc2.EnergyCurrentState="Standby")and (Buffer2.Empty or (Buffer2.cont.name="Entity3"
259
(SingleProc6.EnergyCurrentState="Working") and ((SingleProc6.cont.name="Entity2" or
SingleProc1.ProcTime)>TT) and (SingleProc2.EnergyCurrentState="Operational" or
SingleProc1.ProcTime)>TT) and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty
or (Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5")) and Buffer1.Empty and
(SingleProc6.cont.remainingProcTime< SingleProc5.cont.remainingProcTime)and
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime)<=
(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime))and
260
((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6") ) then
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime)>
SingleProc1.ProcTime)>TT)and ((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-
SingleProc1.ProcTime)>TT)and (((SingleProc6.EnergyCurrentState="Working") and
and ((Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6")or (Buffer2.cont.name="Entity1"
or Buffer2.cont.name="Entity4") or Buffer2.Empty) and Buffer1.Empty and
261
SingleProc1.ProcTime)>TT)and (((SingleProc6.EnergyCurrentState="Working") and
SingleProc6.Empty) and (SingleProc2.EnergyCurrentState="Standby") and
((Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6")or (Buffer2.cont.name="Entity1" or
262
(SingleProc2.EnergyCurrentState="Operational" or SingleProc2.EnergyCurrentState="Working") and
263
((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)<=(SingleProc5.cont.remainingProcT
ime+SingleProc5.ProcTime))and (SingleProc2.EnergyCurrentState="Operational" or
SingleProc2.EnergyCurrentState="Working") and ((Buffer2.cont.name="Entity1" or
((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)>(SingleProc5.cont.remainingProcTi
me+SingleProc5.ProcTime))and (SingleProc2.EnergyCurrentState="Operational" or
264
and (((SingleProc6.EnergyCurrentState="Working" and ((SingleProc6.cont.name="Entity1" or
(SingleProc4.cont.remainingProcTime> SingleProc3.cont.remainingProcTime)and
265
SingleProc4.cont.name="Entity5")))and ((SingleProc4.cont.remainingProcTime-
((SingleProc6.cont.name="Entity2" or SingleProc6.cont.name="Entity6")))and
((SingleProc6.cont.remainingProcTime-SingleProc1.ProcTime)>TT) and
266
(SingleProc6.cont.remainingProcTime<=
SingleProc5.cont.remainingProcTime)and(SingleProc4.cont.remainingProcTime<=
SingleProc3.cont.remainingProcTime)
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)<=(SingleProc6.cont.remainingPr
ocTime+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Operational" or
SingleProc3.cont.remainingProcTime)and
ocTime+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Standby") and
267
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)>(SingleProc6.cont.remainingPro
cTime+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Standby") and
(SingleProc6.cont.remainingProcTime>SingleProc5.cont.remainingProcTime)and(SingleProc4.cont.r
emainingProcTime>
SingleProc3.cont.remainingProcTime)and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcT
ime)<=(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime))and
Buffer3.Empty) then
emainingProcTime> SingleProc3.cont.remainingProcTime)
cTime+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Operational" or
268
Buffer3.Empty) then
Buffer3.Empty) then
(SingleProc5.cont.remainingProcTime<=SingleProc6.cont.remainingProcTime)and(SingleProc2.Ener
gyCurrentState="Operational" or SingleProc2.EnergyCurrentState="Working") and
269
and Buffer1.Empty and (Buffer3.Empty or(Buffer3.cont.name="Entity2" or
ime+SingleProc6.ProcTime))and(SingleProc2.EnergyCurrentState="Operational" or
SingleProc2.EnergyCurrentState="Working") and (Buffer2.Empty or (Buffer2.cont.name="Entity1"
ime+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty
270
me+SingleProc6.ProcTime))and(SingleProc2.EnergyCurrentState="Operational" or
me+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty or
271
(SingleProc3.cont.remainingProcTime <= SingleProc4.cont.remainingProcTime) and
((Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5"))and Buffer1.Empty and
Buffer2.cont.name="Entity5"))and Buffer1.Empty and ((Buffer3.cont.name="Entity1" or
Buffer3.Empty) then
((SingleProc4.cont.remainingProcTime +SingleProc4.ProcTime)<=(
272
((SingleProc4.cont.remainingProcTime +SingleProc4.ProcTime)>(
or Buffer2.cont.name="Entity5"))and Buffer1.Empty and (Buffer3.Empty or
or Buffer2.cont.name="Entity5"))and Buffer1.Empty and (Buffer3.Empty or
273
SingleProc4.EnergyCurrentState="Working" and (SingleProc3.cont.remainingProcTime <=
SingleProc4.cont.remainingProcTime) and (SingleProc2.EnergyCurrentState="Operational" or
SingleProc4.cont.remainingProcTime) and (SingleProc2.EnergyCurrentState="Standby") and
(Buffer2.Empty or (Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5"))and
Buffer3.Empty) then
SingleProc4.cont.name="Entity6"))and(SingleProc3.cont.remainingProcTime<=SingleProc4.cont.rem
ainingProcTime))or SingleProc4.Empty) and
(SingleProc6.cont.remainingProcTime>SingleProc5.cont.remainingProcTime)
((SingleProc4.EnergyCurrentState="Working" and
(SingleProc6.cont.remainingProcTime>SingleProc5.cont.remainingProcTime)and((SingleProc3.cont.r
274
emainingProcTime+SingleProc3.ProcTime)>(SingleProc5.cont.remainingProcTime+SingleProc5.Pro
cTime))and (SingleProc2.EnergyCurrentState="Operational" or
(SingleProc6.cont.remainingProcTime<SingleProc5.cont.remainingProcTime)
275
and((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime-SingleProc1.ProcTime)>TT) and
ime+SingleProc6.ProcTime))and(SingleProc2.EnergyCurrentState="Operational" or
ime+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Standby")and (Buffer2.Empty or
(Buffer3.Empty or (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6")) then
276
me+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Standby")and
me+SingleProc6.ProcTime))and (SingleProc2.EnergyCurrentState="Standby") and
Buffer2.cont.name="Entity6") or Buffer2.Empty ) and Buffer1.Empty and
SingleProc5.cont.name="Entity5"))) or SingleProc5.Empty)and
277
SingleProc1.ProcTime)>TT)) and ((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-
SingleProc1.ProcTime)>TT) and (SingleProc2.EnergyCurrentState="Standby") and
SingleProc1.ProcTime)>TT)and (SingleProc4.EnergyCurrentState="Working" and
((SingleProc4.cont.name="Entity3" or SingleProc4.cont.name="Entity5"))) and
278
SingleProc5.cont.name="Entity5") )) and
SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime))and
((Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5") ) and Buffer1.Empty and
279
280
281
SingleProc1.ProcTime)>TT)and(((SingleProc5.EnergyCurrentState="Working" and
SingleProc5.Empty)and ((SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-
SingleProc1.ProcTime)>TT) and (SingleProc4.cont.remainingProcTime<=
282
or Buffer2.cont.name="Entity5") ) and Buffer1.Empty and (Buffer3.Empty or
--
283
SingleProc1.ProcTime)>TT) and
284
SingleProc1.ProcTime)>TT) and (SingleProc4.cont.remainingProcTime>
SingleProc1.ProcTime)>TT)and ((SingleProc4.EnergyCurrentState="Working" and
285
) and Buffer1.Empty and (Buffer3.Empty or (Buffer3.cont.name="Entity2" or
SingleProc5.cont.name="Entity5"))) and ((SingleProc5.cont.remainingProcTime
+SingleProc5.ProcTime-SingleProc1.ProcTime)>TT)and
286
287
or Buffer2.cont.name="Entity4") or (Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6"))
Buffer3.cont.name="Entity4")or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5"))
288
or Buffer2.cont.name="Entity5")) and Buffer1.Empty and ( Buffer3.Empty or
289
290
SingleProc6.Empty) and
291
SingleProc6.Empty) and (SingleProc3.cont.remainingProcTime>
292
((SingleProc6.cont.remainingProcTime-
SingleProc1.ProcTime)>TT)and(SingleProc3.cont.remainingProcTime<=SingleProc6.cont.remaining
ProcTime) and (SingleProc2.EnergyCurrentState="Operational" or
293
SingleProc1.ProcTime)>TT)and(SingleProc3.cont.remainingProcTime>SingleProc6.cont.remainingPr
ocTime) and (SingleProc2.EnergyCurrentState="Operational" or
ProcTime) and (SingleProc2.EnergyCurrentState="Standby") and ((Buffer2.cont.name="Entity1" or
ocTime) and (SingleProc2.EnergyCurrentState="Standby") and ((Buffer2.cont.name="Entity1" or
294
ProcTime) and (SingleProc6.cont.remainingProcTime<=SingleProc5.cont.remainingProcTime)
SingleProc5.cont.name="Entity6"))and(SingleProc3.EnergyCurrentState="Working" and
295
ocTime) and (SingleProc6.cont.remainingProcTime>SingleProc5.cont.remainingProcTime)
Buffer3.Empty) then
Buffer3.Empty) then
296
SingleProc6.cont.remainingProcTime))or SingleProc6.Empty)
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-SingleProc1.ProcTime)>TT)and
SingleProc1.ProcTime)>TT)and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)<=(Si
ngleProc5.cont.remainingProcTime+SingleProc5.ProcTime))and
297
SingleProc1.ProcTime)>TT)and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)>(Sin
gleProc5.cont.remainingProcTime+SingleProc5.ProcTime))and
SingleProc1.ProcTime)>TT)and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)<=(Si
ngleProc5.cont.remainingProcTime+SingleProc5.ProcTime))and
298
Buffer3.Empty) then
(SingleProc5.cont.name="Entity2" or SingleProc5.cont.name="Entity6"))
and(((SingleProc3.EnergyCurrentState="Working" and ((SingleProc3.cont.name="Entity1" or
SingleProc1.ProcTime)>TT)
and (SingleProc2.EnergyCurrentState="Operational" or SingleProc2.EnergyCurrentState="Working")
299
SingleProc1.ProcTime)>TT)and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty or
SingleProc1.ProcTime)>TT)and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)<=(
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-
SingleProc1.ProcTime)>TT)and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)>(
300
SingleProc1.ProcTime)>TT)and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)<=(
SingleProc1.ProcTime)>TT)and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)>(
and((SingleProc3.EnergyCurrentState="Working" and ((SingleProc3.cont.name="Entity1" or
SingleProc1.ProcTime)>TT)and (SingleProc5.cont.remainingProcTime<=
SingleProc6.cont.remainingProcTime)and (SingleProc2.EnergyCurrentState="Operational" or
301
SingleProc6.cont.remainingProcTime)and (SingleProc2.EnergyCurrentState="Standby") and
302
SingleProc1.ProcTime)>TT)and (SingleProc2.EnergyCurrentState="Operational" or
SingleProc1.ProcTime)>TT)and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty or
303
Buffer3.Empty ) then SingleProc1.startPause(SingleProc3.cont.remainingProcTime-
SingleProc1.ProcTime)>TT)and (SingleProc2.EnergyCurrentState="Standby") and
SingleProc1.startPause(SingleProc3.cont.remainingProcTimeSingleProc3.ProcTime-
SingleProc3.cont.remainingProcTime) and(SingleProc2.EnergyCurrentState="Operational" or
304
SingleProc3.cont.remainingProcTime)and(SingleProc2.EnergyCurrentState="Standby") and
(SingleProc3.cont.remainingProcTime+
SingleProc3.ProcTime))and(SingleProc2.EnergyCurrentState="Operational" or
me+ SingleProc3.ProcTime))and(SingleProc2.EnergyCurrentState="Operational" or
(SingleProc3.cont.remainingProcTime+ SingleProc3.ProcTime))and
305
me+ SingleProc3.ProcTime))and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty
(Buffer3.Empty or (Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity4")or
and(SingleProc3.EnergyCurrentState="Working" and ((SingleProc3.cont.name="Entity3" or
SingleProc1.ProcTime)>TT)and(SingleProc5.EnergyCurrentState="Working" and
306
307
ime+SingleProc5.ProcTime))and
((SingleProc5.cont.name="Entity1" or SingleProc5.cont.name="Entity4")
or(SingleProc5.cont.name="Entity3" or
SingleProc5.cont.name="Entity5")))and((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTim
308
e-SingleProc1.ProcTime)>TT)and
me+SingleProc5.ProcTime))and(SingleProc3.cont.remainingProcTime>SingleProc4.cont.remainingPr
ocTime)and (SingleProc5.cont.remainingProcTime> SingleProc6.cont.remainingProcTime)and
me+SingleProc5.ProcTime))and
Buffer3.Empty) then
309
SingleProc5.Empty) and (SingleProc3.cont.remainingProcTime<=
310
SingleProc5.Empty) and (SingleProc3.cont.remainingProcTime<=
311
312
(Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity5") or Buffer3.Empty ) then
SingleProc3.Empty)and ((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)<=(
313
SingleProc3.Empty)and ((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)>(
314
SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime))
and(SingleProc2.EnergyCurrentState="Operational" or SingleProc2.EnergyCurrentState="Working")
and(SingleProc2.EnergyCurrentState="Standby") and ( Buffer2.Empty or
315
and(SingleProc2.EnergyCurrentState="Standby") and ((Buffer2.cont.name="Entity3" or
316
Buffer3.Empty) then
and (SingleProc6.cont.remainingProcTime<= SingleProc5.cont.remainingProcTime)and
((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6"))
thenSingleProc1.startPause(SingleProc5.cont.remainingProcTime-SingleProc1.ProcTime);
317
and (SingleProc6.cont.remainingProcTime<= SingleProc5.cont.remainingProcTime)and
318
319
(SingleProc3.cont.remainingProcTime> SingleProc4.cont.remainingProcTime)) or
Buffer3.Empty) then
Buffer2.Empty or (Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5")) and
320
Buffer2.Empty or (Buffer2.cont.name="Entity3" or Buffer2.cont.name="Entity5")) and
Buffer3.Empty) then
321
SingleProc1.ProcTime)>TT)and
Buffer3.Empty) then
SingleProc1.ProcTime)>TT)and ((SingleProc5.cont.remainingProcTime+ SingleProc5.ProcTime-
(SingleProc4.cont.name="Entity2" or SingleProc4.cont.name="Entity6") ))or SingleProc4.Empty)and
((SingleProc3.cont.remainingProcTime)<=
((SingleProc3.cont.remainingProcTime)>
322
((SingleProc5.cont.remainingProcTime+ SingleProc5.ProcTime-SingleProc1.ProcTime)>TT)and
323
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime)<(SingleProc5.cont.remainingProcTi
324
((SingleProc3.cont.remainingProcTime)>(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTi
me)) and (SingleProc2.EnergyCurrentState="Operational" or
325
me))and (SingleProc2.EnergyCurrentState="Standby") and ((Buffer2.cont.name="Entity1" or
SingleProc4.cont.name="Entity6") )) and (SingleProc3.cont.remainingProcTime<=
326
(SingleProc4.cont.name="Entity2" or SingleProc4.cont.name="Entity6") )) and
SingleProc3.Empty)and (SingleProc2.EnergyCurrentState="Operational" or
SingleProc3.Empty)and (SingleProc2.EnergyCurrentState="Standby") and
327
(SingleProc4.cont.remainingProcTime>SingleProc3.cont.remainingProcTime))or
SingleProc3.Empty)and (SingleProc2.EnergyCurrentState="Operational" or
Buffer3.Empty) then
(SingleProc4.cont.remainingProcTime>SingleProc3.cont.remainingProcTime))or
SingleProc3.Empty)and (SingleProc2.EnergyCurrentState="Standby") and
328
329
330
331
SingleProc3.cont.name="Entity6") ))and (SingleProc4.cont.remainingProcTime<=
((SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime)<=
((SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime)>
(SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)) and
332
((SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime)>(SingleProc4.cont.remainingProcTi
me+SingleProc4.ProcTime)) and (SingleProc2.EnergyCurrentState="Standby") and (Buffer2.Empty
SingleProc1.ProcTime); --56 56
SingleProc3.cont.name="Entity6") ))or SingleProc3.Empty)and
SingleProc4.cont.name="Entity6")))or SingleProc4.Empty)and
((SingleProc5.cont.remainingProcTime)<=(SingleProc6.cont.remainingProcTime)) and
333
SingleProc1.ProcTime); --
((SingleProc5.cont.remainingProcTime)>(SingleProc6.cont.remainingProcTime)) and
SingleProc1.ProcTime); --
334
Buffer3.Empty) then
Buffer3.Empty) then
((SingleProc3.cont.remainingProcTime)<=(SingleProc4.cont.remainingProcTime))and
Buffer3.Empty) then
335
Buffer3.Empty) then
336
(SingleProc6.EnergyCurrentState="Working"and (SingleProc6.cont.name="Entity2" or
(SingleProc6.EnergyCurrentState="Working"and ((SingleProc6.cont.name="Entity3" or
337
me+SingleProc6.ProcTime)) and (SingleProc2.EnergyCurrentState="Operational" or
((SingleProc5.cont.remainingProcTime)>(SingleProc6.cont.remainingProcTime))and
((SingleProc6.EnergyCurrentState="Working"and ((SingleProc6.cont.name="Entity3" or
ime+SingleProc5.ProcTime)) and (SingleProc2.EnergyCurrentState="Operational" or
338
ime)) and (SingleProc2.EnergyCurrentState="Operational" or
339
((SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime-SingleProc1.ProcTime)>TT)and
340
Buffer1.Empty and (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6")) and
SingleProc2.cont.name="Entity4")) and (SingleProc5.EnergyCurrentState="Working" and
Buffer3.Empty) then
341
Buffer3.Empty) then
342
SingleProc5.cont.name="Entity5")))or SingleProc5.Empty) and
343
(((SingleProc5.EnergyCurrentState="Working"and ((SingleProc5.cont.name="Entity1" or
((SingleProc6.cont.remainingProcTime)<=(SingleProc5.cont.remainingProcTime)))or
344
345
((SingleProc6.cont.remainingProcTime)<=(SingleProc5.cont.remainingProcTime))) or
346
347
((SingleProc4.EnergyCurrentState="Working"and (SingleProc3.cont.remainingProcTime<=
348
ime+SingleProc5.ProcTime))and (SingleProc5.cont.remainingProcTime<=
me+SingleProc5.ProcTime))and (SingleProc3.cont.remainingProcTime<=
SingleProc4.cont.remainingProcTime) and (SingleProc5.cont.remainingProcTime<=
Buffer3.Empty) then
(SingleProc3.cont.remainingProcTime>SingleProc4.cont.remainingProcTime)) or
349
me+SingleProc5.ProcTime)) and
Buffer3.Empty) then
350
SingleProc1.ProcTime)>TT)and((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
351
352
353
Buffer3.Empty) then
Buffer3.Empty) then
354
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime) <=
355
356
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime)<(
357
358
SingleProc3.Empty) then
SingleProc3.Empty) then
359
360
361
362
(SingleProc3.cont.remainingProcTime<SingleProc4.cont.remainingProcTime)and
SingleProc1.ProcTime)>TT)and (SingleProc6.cont.remainingProcTime>
363
((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6"))then
Buffer3.cont.name="Entity5") or Buffer3.Empty)then
364
Buffer3.Empty)then SingleProc1.startPause(SingleProc5.cont.remainingProcTime-
365
366
((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6") )then
((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity6") )then
367
SingleProc4.cont.name="Entity4") or SingleProc4.Empty)) and
368
(SingleProc3.cont.remainingProcTime<=SingleProc4.cont.remainingProcTime)
Buffer3.cont.name="Entity6"))then
369
Buffer3.cont.name="Entity6"))then SingleProc1.startPause(SingleProc4.cont.remainingProcTime-
Buffer2.cont.name="Entity4") or Buffer2.Empty)and Buffer1.Empty and
370
371
372
SingleProc3.cont.name="Entity6")))and(SingleProc4.cont.remainingProcTime<=SingleProc3.cont.re
mainingProcTime)) or SingleProc3.Empty) and
373
374
SingleProc1.ProcTime); else SingleProc1.EnergyCurrentState:="Operational";
end;
end;
is
if (SingleProc1.EnergyCurrentState="Standby" or SingleProc1.pause=true) then
end;
wait (1);
end;
375
end;
is
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
do
@.Op := @.Op+1;
@.move(root.drain);
end;
if Buffer1.empty and Buffer11.empty=false then


SingleProc1.cont.remainingProcTime=0 then SingleProc2.EnergyCurrentState:="Standby"; elseif
Buffer1.empty and Buffer11.empty and SingleProc3.EnergyCurrentState= "Working" and
SingleProc4.cont.name="Entity6")) and SingleProc1.EnergyCurrentState= "Standby" and
SingleProc6.cont.name="Entity5") or (SingleProc6.cont.name="Entity1" or (SingleProc5.Empty or
SingleProc5.cont.name="Entity4") )) ) then
elseif SingleProc5.EnergyCurrentState= " Working" and SingleProc5.cont.remainingProcTime<=TT and
SingleProc4.cont.name="Entity6") ))
and(SingleProc4.cont.remainingProcTime<=SingleProc3.cont.remainingProcTime)) and
((SingleProc6.EnergyCurrentState= " Working" and ((SingleProc6.cont.name="Entity3" or
SingleProc6.cont.name="Entity4") )) or SingleProc6.Empty) and ((Buffer2.cont.name="Entity1" or
(SingleProc1.EnergyCurrentState= "Working" or SingleProc1.EnergyCurrentState= "Operational" )
SingleProc3.cont.name= " Entity3" and SingleProc5.EnergyCurrentState= "Working" and
376
SingleProc3.cont.name= " Entity3" and SingleProc5.EnergyCurrentState= " Working" and
((SingleProc5.cont.remainingProcTime-SingleProc2.ProcTime)>TT) and SingleProc5.cont.name="
Entity2" and ((SingleProc4.EnergyCurrentState= " Working" and (SingleProc4.cont.name= "
Entity2" or SingleProc4.cont.name= " Entity1" )) or SingleProc4.Empty) and
((SingleProc6.EnergyCurrentState= " Working" and (SingleProc6.cont.name= " Entity3" or
SingleProc6.cont.name= " Entity1" )) or SingleProc6.Empty) and (Buffer2.cont.name= " Entity2" or
Buffer2.cont.name= " Entity1" or Buffer2.Empty) and Buffer1.Empty and (Buffer3.cont.name="
Entity1" or Buffer3.con.name= " Entity3" or Buffer3.Empty) and SingleProc1.EnergyCurrentState=
" Standby" then
waituntil SingleProc1.EnergyCurrentState= "Operational" prio 1;
(SingleProc5.cont.name= " Entity3" or SingleProc5.cont.name= " Entity1" )and
((SingleProc5.cont.remainingProcTime+ SingleProc5.ProcTime-SingleProc2.ProcTime)>TT) and
SingleProc4.cont.name= " Entity1" )) or SingleProc4.Empty) and (((SingleProc6.EnergyCurrentState=
" Working" and (SingleProc6.cont.name= " Entity3" or SingleProc6.cont.name= " Entity1"
))and(SingleProc5.cont.remainingProcTime<= SingleProc6.cont.remainingProcTime)) or
SingleProc6.Empty) and (Buffer2.cont.name= " Entity2" or Buffer2.cont.name= " Entity1" or
Buffer2.Empty) and Buffer1.Empty and (Buffer3.cont.name=" Entity2" ) and
(SingleProc1.EnergyCurrentState= " Working" or SingleProc1.EnergyCurrentState= " Operational" )
SingleProc1.EnergyCurrentState= " Standby" then SingleProc2.pause:=true; waituntil
SingleProc1.EnergyCurrentState= "Operational" prio 1; SingleProc2.pause:=false;
))and(SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime)) or
Buffer2.Empty) and Buffer1.Empty and (Buffer3.cont.name=" Entity1" or Buffer3.cont.name="
Entity3" ) and (SingleProc1.EnergyCurrentState= " Working" or SingleProc1.EnergyCurrentState= "
Operational" ) then
377
Entity3" ) and SingleProc1.EnergyCurrentState= " Standby" then SingleProc2.pause:=true; waituntil
SingleProc4.cont.name= " Entity1" )) or SingleProc4.Empty) and SingleProc6.EnergyCurrentState= "
Working" and (SingleProc6.cont.name= " Entity3" or SingleProc6.cont.name= " Entity1" )and
(Buffer2.cont.name= " Entity2" or Buffer2.cont.name= " Entity1" or Buffer2.Empty) and
Buffer1.Empty and (Buffer3.cont.name=" Entity2" ) and (SingleProc1.EnergyCurrentState= "
Working" or SingleProc1.EnergyCurrentState= " Operational" ) then
((SingleProc6.cont.remainingProcTime+ SingleProc6.ProcTime-SingleProc2.ProcTime)>TT)
and(SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime) and
Buffer1.Empty and (Buffer3.cont.name=" Entity1" or Buffer3.cont.name=" Entity3" ) and
Entity1" or Buffer3.con.name= " Entity3" or Buffer3.Empty) and (SingleProc1.EnergyCurrentState=
" Working" or SingleProc1.EnergyCurrentState= " Operational" ) then
" Standby" then SingleProc2.pause:=true; waituntil SingleProc1.EnergyCurrentState= "Operational"
prio 1; SingleProc2.pause:=false;
378
Operational" ) then
379
Buffer1.Empty and (Buffer3.cont.name=" Entity2" ) and SingleProc1.EnergyCurrentState= "
Standby" then SingleProc2.pause:=true; waituntil SingleProc1.EnergyCurrentState= "Operational"
SingleProc3.cont.name= " Entity3" and (SingleProc3.cont.remainingProcTime+
SingleProc3.ProcTime-SingleProc2.ProcTime)>TT and ((SingleProc6.EnergyCurrentState= "
Working" and (SingleProc6.cont.name=" Entity1" or SingleProc6.cont.name=" Entity3" )) or
SingleProc6.Empty) and ((SingleProc5.EnergyCurrentState= " Working" and
(SingleProc5.cont.name= " Entity3" or SingleProc5.cont.name= " Entity1" )) or SingleProc5.Empty)
and ((SingleProc4.EnergyCurrentState= " Working" and (SingleProc4.cont.name= " Entity2" or
SingleProc4.cont.name= " Entity3" ) and
SingleProc4.Empty) and Buffer2.cont.name= " Entity3" and Buffer1.Empty and
(Buffer3.cont.name=" Entity1" or Buffer3.cont.name=" Entity3" or Buffer3.Empty) and
then SingleProc2.startPause(SingleProc3.cont.remainingProcTime+ SingleProc3.ProcTime-
SingleProc3.ProcTime-SingleProc2.ProcTime)>TT and ((SingleProc6.EnergyCurrentState= "
SingleProc3.ProcTime-SingleProc2.ProcTime)>TT and SingleProc4.EnergyCurrentState= " Working"
and (SingleProc4.cont.name= " Entity1" or SingleProc4.cont.name= " Entity2" ) and
((SingleProc6.EnergyCurrentState= " Working" and (SingleProc6.cont.name=" Entity1" or
SingleProc6.cont.name=" Entity3" )) or SingleProc6.Empty) and ((SingleProc5.EnergyCurrentState=
" Working" and (SingleProc5.cont.name= " Entity3" or SingleProc5.cont.name= " Entity1" )) or
380
SingleProc5.Empty) and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" ) and
Buffer1.Empty and (Buffer3.cont.name=" Entity1" or Buffer3.cont.name=" Entity3" or
Buffer3.Empty) and (SingleProc1.EnergyCurrentState= " Working" or
SingleProc1.EnergyCurrentState= " Operational" ) then
Buffer3.Empty) and SingleProc1.EnergyCurrentState= " Standby" then SingleProc2.pause:=true;
waituntil SingleProc1.EnergyCurrentState= "Operational" prio 1; SingleProc2.pause:=false;
Entity1" or Buffer3.con.name= " Entity3" or Buffer3.Empty) and (SingleProc1.EnergyCurrentState=
(SingleProc5.cont.name=" Entity1" or SingleProc5.cont.name=" Entity3" ) and
381
" Working" and (SingleProc6.cont.name= " Entity3" or SingleProc6.cont.name= " Entity1" )) and
" Working" and (SingleProc6.cont.name= " Entity3" or SingleProc6.cont.name= " Entity1" )) and
SingleProc6.EnergyCurrentState= " Working" and
(SingleProc6.cont.name=" Entity1" or SingleProc6.cont.name=" Entity3" )
and((SingleProc3.EnergyCurrentState= " Working" and (SingleProc3.cont.name= " Entity2" or
SingleProc3.cont.name= " Entity1" )) or SingleProc3.Empty) and
382
SingleProc3.cont.name= " Entity1" )) or SingleProc3.Empty) and ((SingleProc5.EnergyCurrentState=
SingleProc5.Empty)and (Buffer2.cont.name= " Entity2" or Buffer2.cont.name= " Entity1" or
Entity3" or Buffer3.Empty) and (SingleProc1.EnergyCurrentState= " Working" or
Entity3" or Buffer3.Empty) and SingleProc1.EnergyCurrentState= " Standby" then
SingleProc2.pause:=true; waituntil SingleProc1.EnergyCurrentState= "Operational" prio 1;
" Working" and (SingleProc5.cont.name= " Entity3" or SingleProc5.cont.name= " Entity1" ))and
383
SingleProc4.cont.name= " Entity3" and
(((SingleProc3.EnergyCurrentState= " Working" and (SingleProc3.cont.name= " Entity2" or
SingleProc3.cont.name= " Entity1" )) and (SingleProc4.cont.remainingProcTime<=
384
SingleProc6.Empty) and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and
and(((SingleProc3.EnergyCurrentState= " Working" and (SingleProc3.cont.name= " Entity2" or
SingleProc3.cont.name= " Entity1" )) and (SingleProc4.cont.remainingProcTime>
SingleProc3.cont.name= " Entity1" )) and (SingleProc4.cont.remainingProcTime>
SingleProc3.cont.name= " Entity1" )) and
385
SingleProc5.cont.name= " Entity2" and ((SingleProc3.EnergyCurrentState= " Working" and
(SingleProc3.cont.name= " Entity3" )) and ((SingleProc3.cont.remainingProcTime-
SingleProc2.ProcTime)>TT))and ((SingleProc6.EnergyCurrentState= " Working" and
Buffer2.cont.name= " Entity2" ) and Buffer1.Empty and (Buffer3.cont.name=" Entity1" or
Buffer3.cont.name=" Entity3" or Buffer3.Empty) and (SingleProc1.EnergyCurrentState= " Working"
or SingleProc1.EnergyCurrentState= " Operational" ) then
(SingleProc3.cont.name= " Entity3" )) and ((SingleProc3.cont.remainingProcTime-
SingleProc2.ProcTime)>TT))and ((SingleProc6.EnergyCurrentState= " Working" and
Buffer2.cont.name= " Entity2" ) and Buffer1.Empty and (Buffer3.cont.name=" Entity1" or
386
Buffer3.cont.name=" Entity3" or Buffer3.Empty) and SingleProc1.EnergyCurrentState= " Standby"
then SingleProc2.pause:=true; waituntil SingleProc1.EnergyCurrentState= "Operational" prio 1;
(SingleProc3.cont.name= " Entity1" or SingleProc3.cont.name= " Entity2" )) and
SingleProc6.cont.name= " Entity1" )) or SingleProc6.Empty) and(((SingleProc4.EnergyCurrentState=
and(SingleProc4.cont.remainingProcTime< SingleProc3.cont.remainingProcTime)) and
SingleProc6.cont.name= " Entity1" )) or SingleProc6.Empty) and (Buffer2.cont.name= " Entity3" )
and Buffer1.Empty and (Buffer3.cont.name=" Entity1" or Buffer3.cont.name=" Entity3" or
and(SingleProc4.cont.remainingProcTime< SingleProc3.cont.remainingProcTime)) and
SingleProc4.cont.name= " Entity2" )) and(SingleProc4.cont.remainingProcTime<
387
SingleProc3.cont.remainingProcTime)) and ((SingleProc6.EnergyCurrentState= " Working" and
and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" ) and Buffer1.Empty and
SingleProc4.cont.name= " Entity2" )) and(SingleProc4.cont.remainingProcTime<
SingleProc3.cont.remainingProcTime)) and ((SingleProc6.EnergyCurrentState= " Working" and
SingleProc5.cont.name= " Entity2" and (SingleProc4.EnergyCurrentState= " Working" and
(SingleProc4.cont.name= " Entity2")) and ((SingleProc4.cont.remainingProcTime-
SingleProc2.ProcTime)>TT)and (SingleProc3.EnergyCurrentState= " Working" and
Entity1" or Buffer3.cont.name=" Entity3" or Buffer3.Empty) and (SingleProc1.EnergyCurrentState=
(SingleProc4.cont.name= " Entity2")) and ((SingleProc4.cont.remainingProcTime-
SingleProc2.ProcTime)>TT)and (SingleProc3.EnergyCurrentState= " Working" and
(SingleProc3.cont.name= " Entity1" or SingleProc3.cont.name= " Entity2") ) and
Entity1" or Buffer3.cont.name=" Entity3" or Buffer3.Empty) and SingleProc1.EnergyCurrentState=
388
389
390
Operational" ) then
SingleProc6.cont.name= " Entity2" and ((SingleProc3.cont.remainingProcTime-
SingleProc2.ProcTime)>TT) and ((SingleProc4.EnergyCurrentState= " Working" and
SingleProc6.cont.name= " Entity2" and ((SingleProc3.cont.remainingProcTime-
(SingleProc3.cont.name= " Entity2" or SingleProc3.cont.name= " Entity1" ) and
((SingleProc3.cont.remainingProcTime+SngleProc3.ProcTime-SingleProc2.ProcTime)>TT) and
391
((SingleProc4.cont.remainingProcTime+SngleProc4.ProcTime-SingleProc2.ProcTime)>TT))and
((SingleProc4.cont.remainingProcTime+SngleProc4.ProcTime-SingleProc2.ProcTime)>TT))and
SingleProc4.cont.name= " Entity1" ))or SingleProc4.Empty) and ((SingleProc5.EnergyCurrentState=
SingleProc4.cont.name= " Entity1" ))or SingleProc4.Empty) and ((SingleProc5.EnergyCurrentState=
(SingleProc4.cont.name= " Entity3" ) and ((SingleProc4.cont.remainingProcTime-
(SingleProc3.cont.name= " Entity2" or SingleProc3.cont.name= " Entity1" ))or SingleProc3.Empty)
392
(SingleProc4.cont.name= " Entity3" ) and ((SingleProc4.cont.remainingProcTime-
(SingleProc3.cont.name= " Entity2" or SingleProc3.cont.name= " Entity1" ))or SingleProc3.Empty)
SingleProc3.cont.name= " Entity1" ))and (SingleProc4.cont.remainingProcTime<=
SingleProc3.cont.name= " Entity1" ))and (SingleProc4.cont.remainingProcTime<=
SingleProc3.cont.name= " Entity1" ))and
393
SingleProc3.ProcTime) and ((SingleProc5.EnergyCurrentState= " Working" and
SingleProc3.ProcTime) and ((SingleProc5.EnergyCurrentState= " Working" and
394
(SingleProc5.EnergyCurrentState= " Working" and (SingleProc5.cont.name= " Entity3" or
(SingleProc5.EnergyCurrentState= " Working" and (SingleProc5.cont.name= " Entity3" or
Operational" ) then
SingleProc4.cont.remainingProcTime<=TT and SingleProc4.cont.name=" Entity3" and
((SingleProc5.cont.remainingProcTime-SingleProc2.ProcTime)> TT) and
(SingleProc5.EnergyCurrentState= " Working" and (SingleProc5.cont.name=" Entity2" )) and
395
((SingleProc6.EnergyCurrentState=" Working" and (SingleProc6.cont.name=" Entity1" or
SingleProc6.cont.name=" Entity3" )) or SingleProc6.Empty) and (SingleProc1.EnergyCurrentState= "
Operational" or (SingleProc1.EnergyCurrentState=" Working" and
SingleProc1.cont.remainingProcTime<=TT)) and (Buffer1.Empty) and (Buffer2.Empty or
Buffer2.cont.name=" Entity1" or Buffer2.cont.name= " Entity2" ) and (Buffer3.cont.name="
Entity1" or Buffer3.cont.name= " Entity3" or Buffer3.Empty) then
(SingleProc5.EnergyCurrentState= " Working" and (SingleProc5.cont.name=" Entity1" or
SingleProc5.cont.name=" Entity3" )) and
SingleProc6.cont.name=" Entity1" )) or SingleProc6.Empty) and
(SingleProc1.EnergyCurrentState= " Operational" or (SingleProc1.EnergyCurrentState=" Working"
and SingleProc1.cont.remainingProcTime<=TT)) and (Buffer2.cont.name= " Entity2" or
Entity2" ) then SingleProc2.startPause(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
SingleProc6.cont.name=" Entity2" )) and (SingleProc5.cont.remainingProcTime>
SingleProc5.EnergyCurrentState= " Working" and (SingleProc5.cont.name=" Entity1" or
SingleProc5.cont.name=" Entity3" ) and
SingleProc1.cont.remainingProcTime<=TT)) and (Buffer2.cont.name= " Entity2" or
Entity1" or Buffer3.con.name= " Entity3" or Buffer3.Empty) then
SingleProc6.EnergyCurrentState=" Working" and (SingleProc6.cont.name=" Entity2" ) and
396
SingleProc6.EnergyCurrentState=" Working" and (SingleProc6.cont.name=" Entity1" or
SingleProc5.cont.name= " Entity3" ) and SingleProc6.EnergyCurrentState=" Working" and
(SingleProc6.cont.name=" Entity1" or SingleProc6.cont.name= " Entity3" ) and
SingleProc6.cont.name= " Entity3" ) and ((SingleProc5.EnergyCurrentState=" Working" and
(SingleProc5.cont.name=" Entity3" or SingleProc5.cont.name=" Entity1" )) or SingleProc5.Empty)
and ((SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc2.ProcTime)> TT) and
SingleProc5.cont.name=" Entity1" )) or SingleProc5.Empty) and ((SingleProc6.EnergyCurrentState="
SingleProc6.Empty) and (SingleProc1.EnergyCurrentState=" Operational" or
(SingleProc1.EnergyCurrentState=" Working" and SingleProc1.cont.remainingProcTime<=TT)) and
(Buffer2.cont.name=" Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or
Buffer3.cont.name= " Entity3" or Buffer3.Empty) then
397
(Buffer2.cont.name=" Entity1" or Buffer2.cont.name= " Entity2" ) and Buffer1.Empty and
(Buffer3.cont.name= " Entity1" or Buffer3.cont.name= " Entity3" or Buffer3.Empty) then
(Buffer2.cont.name=" Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or
Buffer1.Empty and (Buffer3.cont.name= " Entity1" or Buffer3.cont.name= " Entity3" or
Buffer3.Empty) then
elseif SingleProc3.EnergyCurrentState=" Working" and SingleProc3.cont.remainingProcTime<=TT and
SingleProc3.cont.name= " Entity3" and SingleProc5.EnergyCurrentState=" Working" and
SingleProc4.EnergyCurrentState=" Working" and (SingleProc4.cont.name=" Entity3" ) and
SingleProc6.cont.name=" Entity3" )) or SingleProc6.Empty) and (SingleProc1.EnergyCurrentState="
Entity1" or Buffer3.cont.name=" Entity3" or Buffer3.Empty) then
SingleProc4.cont.name=" Entity2" ) and (SingleProc4.cont.remainingProcTime<=
SingleProc3.cont.remainingProcTime)and ((SingleProc6.EnergyCurrentState=" Working" and
and (SingleProc1.EnergyCurrentState=" Operational" or (SingleProc1.EnergyCurrentState="
Working" and SingleProc1.cont.remainingProcTime<=TT)) and (Buffer2.cont.name= " Entity3" )
Buffer3.Empty) then
398
(SingleProc6.EnergyCurrentState=" Working" and (SingleProc6.cont.name=" Entity2" )) and
SingleProc4.cont.name=" Entity2" )) or SingleProc4.Empty ) and (SingleProc1.EnergyCurrentState="
Entity2" ) then SingleProc2.startPause(SingleProc6.cont.remainingProcTime+SingeProc6.ProcTime-
((SingleProc6.EnergyCurrentState=" Working" and (SingleProc6.cont.name= " Entity1" or
SingleProc4.cont.name=" Entity2" )and (SingleProc3.cont.remainingProcTime<=
399
SingleProc1.cont.remainingProcTime<=TT)) and (Buffer2.cont.name= " Entity3" ) and
Buffer3.Empty) then
SingleProc4.cont.name=" Entity2" )and (SingleProc3.cont.remainingProcTime>
SingleProc4.cont.remainingProcTime))) and ((SingleProc6.EnergyCurrentState=" Working" and
(SingleProc6.cont.name=" Entity1" or SingleProc6.cont.name=" Entity3" )) or SingleProc6.Empty )
Working" and SingleProc1.cont.remainingProcTime<=TT)) and (Buffer2.cont.name= " Entity1" or
SingleProc5.cont.remainingProcTime<=TT and SingleProc5.cont.name= " Entity2" and
SingleProc6.cont.name=" Entity3" )and
SingleProc6.Empty ) and ((SingleProc4.EnergyCurrentState=" Working" and
(SingleProc4.cont.name=" Entity1" or SingleProc4.cont.name= " Entity2" )) or SingleProc4.Empty )
Entity2" ) then SingleProc2.startPause(SingleProc5.cont.remainingProcTime+SingeProc5.ProcTime-
SingleProc4.cont.name= " Entity2" )) or SingleProc4.Empty ) and
(SingleProc1.EnergyCurrentState=" Operational" or (SingleProc1.EnergyCurrentState=" Working"
(SingleProc4.EnergyCurrentState=" Working" and SingleProc4.cont.name=" Entity3" )and
400
Buffer3.Empty) then
SingleProc2.startPause(SingleProc4.cont.remainingProcTime+SngleProc4.ProcTime-
((SingleProc5.cont.remainingProcTime-SingleProc2.ProcTime)> TT)and
SingleProc4.cont.name=" Entity2" )) or SingleProc4.Empty ) and (SingleProc1.EnergyCurrentState= "
(SingleProc5.EnergyCurrentState=" Working" and (SingleProc5.cont.name=" Entity1" or
SingleProc5.cont.name=" Entity3" ))and ((SingleProc5.cont.remainingProcTime+
SingleProc5.cont.name=" Entity3" ))and ((SingleProc5.cont.remainingProcTime+
401
SingleProc5.cont.name=" Entity3" )) or SingleProc5.Empty ) and (SingleProc1.EnergyCurrentState=
" Operational" or (SingleProc1.EnergyCurrentState=" Working" and
Buffer3.Empty) then
SingleProc4.cont.name=" Entity2" )) or SingleProc4.Empty ) and (SingleProc1.EnergyCurrentState=
" Operational" or (SingleProc1.EnergyCurrentState=" Working" and
SingleProc5.cont.name=" Entity5" )and (SingleProc6.cont.remainingProcTime>
SingleProc5.cont.remainingProcTime)) ) and ((SingleProc4.EnergyCurrentState=" Working" and
(SingleProc4.cont.name=" Entity1" or SingleProc4.cont.name=" Entity2" )) or SingleProc4.Empty )
and (SingleProc1.EnergyCurrentState= " Operational" or (SingleProc1.EnergyCurrentState="
elseif (SingleProc4.EnergyCurrentState=" Working" and SingleProc4.cont.remainingProcTime<=TT and
SingleProc4.cont.name=" Entity3" ) and (SingleProc5.EnergyCurrentState=" Working" and
SingleProc5.cont.remainingProcTime<=TT and SingleProc5.cont.name=" Entity2" ) and
402
(SingleProc3.EnergyCurrentState=" Working" and( SingleProc3.cont.name=" Entity1" or
SingleProc3.cont.name=" Entity2" ))and
((SingleProc3.cont.remainingProcTime+SigleProc3.ProcTime-SingleProc2.ProcTime)>TT) and
Buffer3.Empty) then
((SingleProc3.cont.remainingProcTime+SigleProc3.ProcTime-SingleProc2.ProcTime)>TT) and
(SingleProc6.EnergyCurrentState=" Working" and ( SingleProc6.cont.name=" Entity2" )) and
Entity2" ) then SingleProc2.startPause(SingleProc6.cont.remainingProcTime+SngleProc6.ProcTime-
403
(((SingleProc3.EnergyCurrentState=" Working" and (SingleProc3.cont.name=" Entity1" or
SingleProc3.cont.name=" Entity2" )) and (SingleProc4.cont.remainingProcTime<=
Buffer3.Empty) then
404
SingleProc3.EnergyCurrentState=" Working" and (SingleProc3.cont.name=" Entity3" )
and((SingleProc3.cont.remainingProcTime-SingleProc2.ProcTime)>TT) and
SingleProc3.cont.name=" Entity2" ) and((SingleProc3.cont.remainingProcTime
SingleProc4.cont.remainingProcTime) and ((SingleProc5.EnergyCurrentState=" Working" and
Buffer3.Empty) then
SingleProc5.EnergyCurrentState=" Working" and (SingleProc5.cont.name=" Entity2" )
405
Buffer2.cont.name= " Entity2" or Buffer2.Empty ) and Buffer1.Empty and (Buffer3.cont.name="
Entity1" or Buffer3.cont.name=" Entity3" or Buffer3.Empty ) then
406
(SingleProc3.EnergyCurrentState=" Working" and SingleProc3.cont.name=" Entity3" and
((SingleProc3.cont.remainingProcTime-SingleProc2.ProcTime)>TT)) and
Buffer2.cont.name= " Entity1" or Buffer2.Empty) and Buffer1.Empty and (Buffer3.cont.name= "
(Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity3" or
and SingleProc1.cont.remainingProcTime<=TT)) and (Buffer2.cont.name= " Entity3" ) and
Buffer3.Empty) then
407
Buffer2.cont.name= " Entity2" or Buffer2.Empty ) and Buffer1.Empty and (Buffer3.cont.name= "
(SingleProc4.EnergyCurrentState=" Working" and SingleProc4.cont.name=" Entity3" )
(SingleProc4.EnergyCurrentState=" Working" and ( SingleProc4.cont.name=" Entity1" or
SingleProc4.cont.name=" Entity2" )) and((SingleProc4.cont.remainingProcTime
+SingleProc4.ProcTime-SingleProc2.ProcTime)>TT) and (((SingleProc3.EnergyCurrentState="
Working" and (SingleProc3.cont.name=" Entity2" or SingleProc3.cont.name=" Entity1" )) and
+SingleProc4.ProcTime-SingleProc2.ProcTime)>TT) and (SingleProc3.EnergyCurrentState="
Working" and ( SingleProc3.cont.name=" Entity1" or SingleProc3.cont.name=" Entity2" ))
and((SingleProc3.cont.remainingProcTime +SingleProc3.ProcTime-SingleProc1.ProcTime)>TT) and
Buffer3.Empty) then
+SingleProc4.ProcTime-SingleProc2.ProcTime)>TT) and (((SingleProc3.EnergyCurrentState="
408
Buffer3.Empty) then
Entity2" ) then SingleProc2.startPause(SingleProc5.cont.remainingProcTime +
Entity2" ) then SingleProc2.startPause(SingleProc6.cont.remainingProcTime +
409
Operational" or (SingleProc1.EnergyCurrentState=" Working" )) and (Buffer2.cont.name= " Entity3"
) and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or Buffer3.cont.name= " Entity3" or
Buffer3.Empty) and (SingleProc3.cont.remainingProcTime<= SingleProc4.cont.remainingProcTime)
then SingleProc2.startPause(SingleProc3.cont.remainingProcTime + SingleProc3.ProcTime-
Standby" ) and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= "
Entity1" or Buffer3.cont.name= " Entity3" or Buffer3.Empty) and
(SingleProc3.cont.remainingProcTime<= SingleProc4.cont.remainingProcTime) then
Buffer3.Empty) and (SingleProc3.cont.remainingProcTime> SingleProc4.cont.remainingProcTime)
410
((SingleProc5.cont.remainingProcTime-SingleProc2.ProcTime)>TT))and
and
411
SingleProc6.cont.name=" Entity3" ))and (SingleProc5.cont.remainingProcTime<=
(SingleProc2.EnergyCurrentState=" Operational" or (SingleProc1.EnergyCurrentState=" Working" ))
and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) and
SingleProc6.cont.name=" Entity3" ))and (SingleProc5.cont.remainingProcTime>=
SingleProc6.cont.remainingProcTime)) and (SingleProc1.EnergyCurrentState=" Operational" or
(SingleProc1.EnergyCurrentState=" Working" )) and (Buffer2.cont.name= " Entity3" ) and
))and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or
Buffer3.cont.name= " Entity3" or Buffer3.Empty ) and
412
(SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= " Entity3" ) and
Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) and
SingleProc6.cont.name=" Entity3" ))and (SingleProc5.cont.remainingProcTime>
SingleProc6.cont.remainingProcTime))) and (SingleProc1.EnergyCurrentState=" Standby" ) and
Buffer3.cont.name= " Entity3" or Buffer3.Empty) and
and
413
and
Standby" )and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= "
414
((SingleProc6.cont.remainingProcTime+SingleProc6.ProcTme-SingleProc2.ProcTime)>TT))and
))and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) and
SingleProc5.cont.remainingProcTime))) and (SingleProc1.EnergyCurrentState=" Operational" or
and
))and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) and
and
415
(SingleProc1.EnergyCurrentState=" Standby" )and (Buffer2.cont.name= " Entity3" ) and
SingleProc5.cont.remainingProcTime))) and (SingleProc1.EnergyCurrentState=" Standby" )and
(Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name=" Entity1" or
Buffer3.Empty or Buffer3.cont.name=" Entity3" ) and
416
and
and
Standby" )and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= "
417
SingleProc1.EnergyCurrentState=" Working" )and (Buffer2.cont.name= " Entity3" ) and
Buffer1.Empty and (Buffer3.cont.name=" Entity2" ) and
(SingleProc1.EnergyCurrentState=" Operational" or SingleProc1.EnergyCurrentState=" Working"
)and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name=" Entity1" or
Buffer3.cont.name=" Entity3" or Buffer3.Empty) and
SingleProc1.EnergyCurrentState=" Working" )and (Buffer2.cont.name= " Entity3" ) and
Buffer1.Empty and (Buffer3.cont.name=" Entity2" ) and
418
(SingleProc1.EnergyCurrentState=" Operational" or SingleProc1.EnergyCurrentState=" Working"
)and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name=" Entity1" or
Buffer3.cont.name=" Entity3" or Buffer3.Empty ) and
SingleProc6.Empty) and (SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= "
Entity3" ) and Buffer1.Empty and (Buffer3.cont.name=" Entity2" ) and
and(SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime>SingleProc5.cont.remainingProcTi
me+SingleProc5.ProcTime) then
SingleProc6.Empty) and (SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= "
Entity3" ) and Buffer1.Empty and (Buffer3.cont.name=" Entity2" ) and
419
and
and
and
420
and
421
and
422
and (Buffer2.cont.name= " Entity2" or Buffer2.cont.name= " Entity1" or Buffer2.Empty) and
Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
Buffer1.Empty and (Buffer3.cont.name= " Entity1" or Buffer3.Empty or Buffer3.cont.name= "
423
(SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= " Entity2" or
Entity1" or Buffer3.Empty or Buffer3.cont.name= " Entity3" ) then
Entity3" or Buffer3.cont.name= " Entity2" ) then
Entity1" or Buffer3.Empty or Buffer3.cont.name= " Entity3" or Buffer3.cont.name= " Entity2" )
Entity3" or Buffer3.cont.name= " Entity2" ) then
424
Entity1" or Buffer3.Empty or Buffer3.cont.name= " Entity3" or Buffer3.cont.name= " Entity2" )
425
(SingleProc1.EnergyCurrentState=" Working" )) and (Buffer2.cont.name= " Entity2" or
SingleProc5.cont.remainingProcTime))) and (SingleProc1.EnergyCurrentState=" Standby" )and
and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or
Buffer3.Empty or Buffer3.cont.name= " Entity3" ) then
426
Entity3" ) then SingleProc2.startPause(SingleProc3.cont.remainingProcTime
SingleProc4.cont.name=" Entity1"))and
+SingleProc4.ProcTime)and (SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name=
" Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or Buffer3.Empty or
Buffer3.cont.name= " Entity3" ) then SingleProc2.startPause(SingleProc3.cont.remainingProcTime
427
Entity3" ) then SingleProc2.startPause(SingleProc4.cont.remainingProcTime
and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
428
Buffer3.Empty) then SingleProc2.startPause(SingleProc3.cont.remainingProcTime
(SingleProc6.EnergyCurrentState=" Working" ) and (SingleProc6.cont.name=" Entity2" )and
429
(SingleProc6.EnergyCurrentState=" Working" ) and (SingleProc6.cont.name=" Entity2" )and
Buffer3.Empty) then SingleProc2.startPause(SingleProc3.cont.remainingProcTime
(SingleProc6.EnergyCurrentState=" Working" ) and (SingleProc6.cont.name=" Entity1" or
430
(((SingleProc6.EnergyCurrentState=" Working" ) and (SingleProc6.cont.name=" Entity1" or
SingleProc6.cont.name=" Entity3" ))or SingleProc6.Empty) and (SingleProc1.EnergyCurrentState="
or Buffer2.cont.name= " Entity1" or Buffer2.Empty) and Buffer1.Empty and (Buffer3.cont.name= "
Entity1" or Buffer3.cont.name= " Entity3" or Buffer3.Empty ) then
(((SingleProc6.EnergyCurrentState=" Working" ) and (SingleProc6.cont.name=" Entity1" or
SingleProc6.cont.name=" Entity3" ))or SingleProc6.Empty) and (SingleProc1.EnergyCurrentState="
Standby" ) and (Buffer2.cont.name= " Entity2" or Buffer2.cont.name= " Entity1" or Buffer2.Empty)
and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or Buffer3.cont.name= " Entity3" or
((SingleProc4.cont.remainingProcTime-ProcTime2.ProcTime)>TT)and
((SingleProc4.cont.remainingProcTime-ProcTime2.ProcTime)>TT)and
431
(SingleProc1.EnergyCurrentState=" Operational" or SingleProc1.EnergyCurrentState=" Working" )
432
ime+SingleProc5.ProcTime))and (SingleProc1.EnergyCurrentState=" Operational" or
SingleProc1.EnergyCurrentState=" Working" ) and (Buffer2.cont.name= " Entity1" or
me+SingleProc5.ProcTime))and (SingleProc1.EnergyCurrentState=" Operational" or
433
(SingleProc4.EnergyCurrentState=" Working" and (SingleProc4.cont.name=" Entity3" ))and
434
SingleProc1.EnergyCurrentState=" Working" ) and (Buffer2.cont.name= " Entity3" ) and
ime+SingleProc6.ProcTime))and (SingleProc1.EnergyCurrentState=" Standby" ) and
435
(Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
me+SingleProc6.ProcTime))and (SingleProc1.EnergyCurrentState=" Standby" ) and
emainingProcTime> SingleProc3.cont.remainingProcTime) and
Buffer2.cont.name= " Entity2" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or
436
(Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" ) and Buffer1.Empty and
(Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" ) and Buffer1.Empty and
437
ime+SngleProc6.ProcTime))and (SingleProc1.EnergyCurrentState=" Operational" or
ime+SngleProc6.ProcTime))and (SingleProc1.EnergyCurrentState=" Standby" ) and
me+SngleProc6.ProcTime))and (SingleProc1.EnergyCurrentState=" Operational" or
me+SngleProc6.ProcTime))and (SingleProc1.EnergyCurrentState=" Standby" ) and
438
and (Buffer2.cont.name= " Entity3" )and Buffer1.Empty and (Buffer3.cont.name= " Entity1" or
(SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= " Entity3" )and
Buffer3.Empty) then
439
Buffer3.Empty) then
Buffer3.Empty) then
440
Buffer3.Empty) then
SingleProc4.cont.name=" Entity2" ))or SingleProc4.Empty) and
emainingProcTime<=SingleProc4.cont.remainingProcTime) and
emainingProcTime<=SingleProc4.cont.remainingProcTime)and
emainingProcTime<=SingleProc4.cont.remainingProcTime)and
441
(SingleProc6.cont.remainingProcTime<SingleProc5.cont.remainingProcTime)and(SingleProc3.cont.r
emainingProcTime<=SingleProc4.cont.remainingProcTime) and
ime+SingleProc6.ProcTime))and (SingleProc1.EnergyCurrentState=" Standby" )and
442
me+SingleProc6.ProcTime))and (SingleProc1.EnergyCurrentState=" Standby" )and
(Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty ) and
SingleProc5.cont.name=" Entity3" )) or SingleProc5.Empty)and (SingleProc4.EnergyCurrentState="
Working" and (SingleProc4.cont.name=" Entity3" )) and ((SingleProc4.cont.remainingProcTime-
SingleProc2.ProcTime)>TT) and (SingleProc1.EnergyCurrentState=" Operational" or
443
SingleProc5.cont.name=" Entity3" )) or SingleProc5.Empty)and ((SingleProc4.EnergyCurrentState="
SingleProc2.ProcTime)>TT) and (SingleProc1.EnergyCurrentState=" Standby" ) and
Buffer3.Empty) then
and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty ) and
444
445
(SingleProc1.EnergyCurrentState=" Standby" )and (Buffer2.cont.name= " Entity1" or
446
(SingleProc1.EnergyCurrentState=" Standby" )and (Buffer2.cont.name= " Entity1" or
447
448
449
Operational" or SingleProc1.EnergyCurrentState=" Working" ) and (Buffer2.cont.name= " Entity1"
or Buffer2.cont.name= " Entity2" or Buffer2.Empty ) and Buffer1.Empty and (Buffer3.cont.name= "
Entity2" ) then SingleProc2.startPause(SingleProc5.cont.remainingProcTime-SingleProc2.ProcTime);
Standby" ) and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty
) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
SingleProc5.cont.name=" Entity3" )) and ((SingleProc5.cont.remainingProcTime
450
or Buffer2.cont.name= " Entity2" or Buffer2.Empty ) and Buffer1.Empty and (Buffer3.cont.name= "
451
Standby" ) and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty
Buffer3.Empty) then
Buffer3.Empty) then
452
Buffer3.Empty) then
Buffer3.Empty) then
453
454
455
456
SingleProc5.cont.remainingProcTime<=TT and SingleProc5.cont.name=" Entity2" )and
ocTime+SingleProc6.ProcTime)) and (SingleProc1.EnergyCurrentState=" Operational" or
cTime+SingleProc6.ProcTime)) and (SingleProc1.EnergyCurrentState=" Operational" or
457
ocTime+SingleProc6.ProcTime)) and (SingleProc1.EnergyCurrentState=" Standby" ) and
cTime+SingleProc6.ProcTime)) and (SingleProc1.EnergyCurrentState=" Standby" ) and
ocTime+SingleProc6.ProcTime)) and (SingleProc1.EnergyCurrentState=" Operational" or
cTime+SingleProc6.ProcTime)) and (SingleProc1.EnergyCurrentState=" Operational" or
458
ocTime+SingleProc6.ProcTime)) and (SingleProc1.EnergyCurrentState=" Standby" ) and
Buffer3.Empty) then
cTime+SingleProc6.ProcTime)) and (SingleProc1.EnergyCurrentState=" Standby" ) and
Buffer3.Empty) then
ime+SingleProc5.ProcTime)) and (SingleProc1.EnergyCurrentState=" Operational" or
me+SingleProc5.ProcTime)) and (SingleProc1.EnergyCurrentState=" Operational" or
459
ime+SingleProc5.ProcTime)) and (SingleProc1.EnergyCurrentState=" Standby" ) and
me+SingleProc5.ProcTime)) and (SingleProc1.EnergyCurrentState=" Standby" ) and
460
Buffer3.Empty) then
Buffer3.Empty) then
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)<=(
461
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-SingleProc2.ProcTime)>TT)
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime)>(
SingleProc6.cont.remainingProcTime) and (SingleProc1.EnergyCurrentState=" Operational" or
Entity2" ) then SingleProc2.startPause(SingleProc6.cont.remainingProcTime-
462
SingleProc6.cont.remainingProcTime) and (SingleProc1.EnergyCurrentState=" Standby" ) and
Entity2" ) then
463
Entity2" ) then
Entity2" ) then SingleProc2.startPause(SingleProc6.cont.remainingProcTime-
SingleProc2.ProcTime)>TT)and (SingleProc1.EnergyCurrentState=" Standby" ) and
SingleProc2.ProcTime)>TT)and (SingleProc1.EnergyCurrentState=" Operational" or
SingleProc2.ProcTime)>TT)and (SingleProc1.EnergyCurrentState=" Standby" ) and
464
SingleProc3.cont.remainingProcTime) and (SingleProc1.EnergyCurrentState=" Standby" ) and
Buffer3.cont.name= " Entity3" or Buffer3.Empty ) then
(SingleProc3.cont.remainingProcTime+ SingleProc3.ProcTime)) and
me+ SingleProc3.ProcTime)) and (SingleProc1.EnergyCurrentState=" Operational" or
465
me+ SingleProc3.ProcTime)) and (SingleProc1.EnergyCurrentState=" Standby" ) and
466
467
Buffer3.Empty) then
Buffer3.Empty) then
468
469
470
471
472
and(SingleProc1.EnergyCurrentState=" Operational" or SingleProc1.EnergyCurrentState=" Working"
) and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
) and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
and(SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= " Entity3" ) and
473
and(SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= " Entity3" ) and
) and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty) and
Buffer3.Empty) then
and(SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= " Entity1" or
474
or Buffer2.cont.name= " Entity2" or Buffer2.Empty) and Buffer1.Empty and (Buffer3.cont.name= "
Standby" ) and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty)
and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
475
476
Buffer3.Empty) then
Buffer3.Empty) then
and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty or
Buffer2.cont.name= " Entity2" or Buffer2.Empty or Buffer2.cont.name= " Entity3" ) and
and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty or
477
Buffer2.cont.name= " Entity2" or Buffer2.Empty or Buffer2.cont.name= " Entity3" ) and
Buffer3.Empty) then
478
Buffer3.Empty) then
SingleProc4.cont.name=" Entity2" ))or SingleProc4.Empty)and
479
480
me)) and (SingleProc1.EnergyCurrentState=" Operational" or SingleProc1.EnergyCurrentState="
Working" ) and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty
) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
me)) and (SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= " Entity1" or
481
482
Buffer3.Empty) then
and (SingleProc1.EnergyCurrentState=" Operational" or SingleProc1.EnergyCurrentState="
Working" ) and (Buffer2.cont.name= " Entity1" or Buffer2.cont.name= " Entity2" or Buffer2.Empty)
Buffer3.Empty) then
and (SingleProc1.EnergyCurrentState=" Standby" ) and (Buffer2.cont.name= " Entity1" or
483
484
485
486
((SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime)>
487
((SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime)>(SingleProc4.cont.remainingProcTi
SingleProc3.cont.name=" Entity2" ))or SingleProc3.Empty)and ((SingleProc4.EnergyCurrentState="
Working" and (SingleProc4.cont.name=" Entity1" or SingleProc4.cont.name=" Entity2" ))or
SingleProc4.Empty)and
488
(SingleProc5.EnergyCurrentState=" Working" and SingleProc5.cont.remainingProcTime<=TT and
Buffer3.Empty) then
Buffer3.Empty) then
Buffer3.Empty) then
489
Buffer3.Empty) then
Buffer1.Empty and (Buffer3.cont.name= " Entity1" or Buffer3.cont.name= " Entity3" ) then
(SingleProc6.EnergyCurrentState=" Working" and SingleProc6.cont.name=" Entity2" ) and
490
(SingleProc6.EnergyCurrentState=" Working" and SingleProc6.cont.name=" Entity2" ) and
Buffer3.cont.name= " Entity3" ) then
491
SingleProc6.cont.name=" Entity1" )) or SingleProc6.Empty)and
ime)) and (SingleProc1.EnergyCurrentState=" Operational" or (SingleProc1.EnergyCurrentState="
Buffer3.Empty) then
492
me)) and (SingleProc1.EnergyCurrentState=" Operational" or (SingleProc1.EnergyCurrentState="
493
((SingleProc6.cont.remainingProcTime+SIngleProc6.ProcTime-SingleProc2.ProcTime)>TT)and
(SingleProc6.cont.name=" Entity2" )) and ((SingleProc6.cont.remainingProcTime-
SingleProc5.cont.name=" Entity3" )) or SingleProc5.ProcTime) and
Buffer3.Empty) then
SingleProc5.cont.name=" Entity3" )) or SingleProc5.ProcTime) and
Buffer3.Empty) then
494
Buffer3.Empty) then
495
496
Buffer3.Empty) then
497
(SingleProc5.cont.name=" Entity2" ))and ((SingleProc5.cont.remainingProcTime-
498
(SingleProc5.cont.name=" Entity1" or SingleProc5.cont.name=" Entity3" ))and
499
SingleProc6.cont.name=" Entity2" ) and ((SingleProc4.EnergyCurrentState=" Working" and
(SingleProc4.cont.name=" Entity1" or SingleProc4.cont.name=" Entity2" )) or
ime+SingleProc5.ProcTime))and (SingleProc3.cont.remainingProcTime<=
me+SingleProc5.ProcTime))and (SingleProc3.cont.remainingProcTime<=
500
SingleProc6.cont.name=" Entity2" ) and (((SingleProc4.EnergyCurrentState=" Working" and
(SingleProc4.cont.name=" Entity1" or SingleProc4.cont.name=" Entity2" )) and
SingleProc6.cont.name=" Entity2" ) and (((SingleProc4.EnergyCurrentState=" Working" and
501
502
503
Buffer3.Empty) then
Buffer3.Empty) then
SingleProc4.ProcTime) and ((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
504
SingleProc4.ProcTime) and ((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
((SingleProc3.cont.remainingProcTime+SingleProc3.ProcTime) <=
505
SingleProc2.ProcTime); --456 45 elseif (SingleProc4.EnergyCurrentState=" Working" and
Buffer2.cont.name= " Entity2" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" ) then
506
507
Entity1" or Buffer3.cont.name= " Entity3" or SingleProc3.Empty) then
Entity1" or Buffer3.cont.name= " Entity3" or SingleProc3.Empty) then
508
509
510
511
and (Buffer2.cont.name= " Entity3" ) and Buffer1.Empty and (Buffer3.cont.name= " Entity2" )then
512
Buffer3.cont.name= " Entity3" or Buffer3.Empty)then
and (Buffer2.cont.name= " Entity1" or Buffer2.Empty or Buffer2.cont.name= " Entity2" ) and
Buffer1.Empty and (Buffer3.cont.name= " Entity2" )then
513
514
(SingleProc5.EnergyCurrentState=" Working" and (SingleProc5.cont.name=" Entity2") ) and
515
516
and (Buffer2.cont.name= " Entity3" )and Buffer1.Empty and (Buffer3.cont.name= " Entity2" )then
517
and (Buffer2.cont.name= " Entity2" or Buffer2.cont.name= " Entity1" or Buffer2.Empty)and
and (Buffer2.cont.name= " Entity2" or Buffer2.cont.name= " Entity1" or Buffer2.Empty)and

518
519
SingleProc3.cont.name=" Entity2"
))and(SingleProc4.cont.remainingProcTime<=SingleProc3.cont.remainingProcTime)) or
SingleProc3.Empty) and ((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-
520
SingleProc3.cont.name=" Entity3" )and (SingleProc4.EnergyCurrentState=" Working" and
521
(SingleProc3.cont.name="Entity2" or SingleProc3.cont.name="Entity6") ))) and (SingleProc4.Empty
SingleProc5.cont.name="Entity4") or ((((SingleProc5.cont.name="Entity3" or
SingleProc5.cont.name="Entity5") or SingleProc5.cont.name="Entity5") or
SingleProc5.cont.name="Entity5") or SingleProc5.cont.name="Entity5") ))) and (SingleProc6.Empty
SingleProc6.cont.name="Entity4") or ((SingleProc6.cont.name="Entity3" or
SingleProc6.cont.name="Entity5") or SingleProc6.cont.name="Entity5") ))) then
end;
end;
is
end;
wait (1);
end;
522
end;
A.2.3.3 Stage B- routing phase and exit control

is
target: object;
Entity1: string;
Entity3: string;
do
if SingleProc3.pause=true and SingleProc4.pause=true then
waituntil (SingleProc4.pause=false or SingleProc3.pause=false) prio 1;
print "entrambe in pausa reparto2";
elseif Buffer22.Empty and SingleProc1.EnergyCurrentState="Working" and

SingleProc1.cont.name="Entity3" and SingleProc2.EnergyCurrentState="Standby" and
SingleProc3.pause=true and SingleProc4.EnergyCurrentState="Standby" and
SingleProc5.Empty and
SingleProc6.EnergyCurrentState="Working" and SingleProc6.cont.name="Entity1" and
Buffer11.Empty=false and
Buffer33.Empty=false then
elseif SingleProc1.EnergyCurrentState="Standby" and SingleProc2.EnergyCurrentState="Standby"

and SingleProc4.EnergyCurrentState="Standby" and
SingleProc3.pause=true and SingleProc5.EnergyCurrentState="Working" and
SingleProc5.cont.name="Entity1" and
SingleProc6.EnergyCurrentState="Working" and SingleProc6.cont.name="Entity1" then
elseif SingleProc3.EnergyCurrentState="Standby" and SingleProc4.pause=true and

Buffer22.Empty then
Buffer22.Empty then
523
then
"Standby" then
and (SingleProc3.cont.remainingProcTime)<=TT then
end;
@.move(target);
else
@.move;
end;
end;
is
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
Do @.Op := @.Op+1;
@.move(root.drain);
524
end;
if Buffer2.Empty and Buffer22.Empty=false then

SingleProc4.cont.remainingProcTime=0 then SingleProc3.EnergyCurrentState:="Standby"; elseif
(SingleProc1.cont.name="Entity1" or SingleProc1.cont.name="Entity6") and Buffer2.Empty and
Buffer22.Empty and SingleProc2.Empty and SingleProc5.Empty and SingleProc6.Empty then
elseif Buffer22.Empty and Buffer2.Empty and SingleProc1.EnergyCurrentState="Working" and
SingleProc2.EnergyCurrentState="Standby" and SingleProc4.EnergyCurrentState="Standby" and
SingleProc5.EnergyCurrentState="Working" and (SingleProc5.cont.name="Entity2" or
SingleProc5.cont.name="Entity5") and SingleProc6.EnergyCurrentState="Working" and
(SingleProc6.cont.name="Entity3" or SingleProc6.cont.name="Entity4") and Buffer11.Empty=false
and Buffer33.Empty=false then print "ultima Entity3 reparto2";
elseif SingleProc2.Empty and SingleProc1.Empty and SingleProc6.Empty and (SingleProc2.Empty or
SingleProc2.cont.name="Entity5")))) and (SingleProc1.Empty or
SingleProc1.cont.name="Entity5")))) and SingleProc5.EnergyCurrentState="Working" and
SingleProc5.cont.name="Entity4") and Buffer2.Empty and Buffer22.Empty and Buffer1.Empty and
Buffer3.Empty and Buffer33.Empty=false and SingleProc4.EnergyCurrentState="Standby" then
elseif Buffer2.Empty and Buffer22.Empty and (Buffer3.Empty or Buffer3.cont.name="Entity1" or
Buffer3.cont.name="Entity2" ) and (Buffer33.Empty or Buffer33.cont.name="Entity1" or
Buffer33.cont.name="Entity2" ) and SingleProc5.EnergyCurrentState= "Working" and
SingleProc5.cont.name="Entity4") then
SingleProc5.EnergyCurrentState= "Working" and (SingleProc5.cont.remainingProcTime-
SingleProc3.ProcTime)>TT and (SingleProc5.cont.name="Entity3" or
Buffer3.cont.name="Entity1" or (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity5") ) and
525
SingleProc6.cont.name="Entity5") ))) then SingleProc3.EnergyCurrentState:="Standby";
elseif SingleProc2.EnergyCurrentState="Working" and (SingleProc2.cont.name="Entity1" or
SingleProc2.cont.name="Entity6") and SingleProc2.cont.remainingProcTime<=TT and
SingleProc5.cont.name="Entity4") and SingleProc5.cont.remainingProcTime<=TT and
(SingleProc6.Empty or (SingleProc6.EnergyCurrentState="Working" and
SingleProc6.cont.name="Entity4") ) or (SingleProc6.EnergyCurrentState="Working" and
(SingleProc6.cont.name="Entity2" or SingleProc6.cont.name="Entity5")))) and (SingleProc1.Empty
(SingleProc1.EnergyCurrentState="Working" and((SingleProc1.cont.name="Entity3" or
SingleProc1.cont.name="Entity5")))) and Buffer1.Empty and Buffer2.Empty and Buffer3.Empty and
SingleProc4.EnergyCurrentState="Standby" then print "vincolo M3 25-61";
Buffer3.cont.name="Entity1" or (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity5") ) and
SingleProc4.EnergyCurrentState= "Standby" then SingleProc3.pause:=true; waituntil
SingleProc4.EnergyCurrentState="Operational" prio 1; SingleProc3.pause:=false;
SingleProc5.EnergyCurrentState= "Working" and (SingleProc5.cont.remainingProcTime+
SingleProc5.ProcTime-SingleProc3.ProcTime)>TT and ((SingleProc5.cont.name="Entity1" or
SingleProc5.cont.name="Entity5")) and ((SingleProc2.EnergyCurrentState= "Working" and
and Buffer2.Empty and ( Buffer3.Empty or Buffer3.cont.name="Entity3") and
526
and Buffer2.Empty and (Buffer3.Empty or Buffer3.cont.name="Entity3") and
and Buffer2.Empty and (Buffer3.Empty or Buffer3.cont.name="Entity1" or
Buffer3.cont.name="Entity2") and (SingleProc4.EnergyCurrentState= "Working" or
Buffer3.cont.name="Entity2") and SingleProc4.EnergyCurrentState= "Standby" then
SingleProc3.pause:=true; waituntil SingleProc4.EnergyCurrentState="Operational" prio 1;
SingleProc5.cont.name="Entity5")) and SingleProc6.EnergyCurrentState= "Working" and
527
Buffer1.cont.name="Entity4") ) and Buffer2.Empty and (Buffer3.cont.name="Entity1" or
(SingleProc2.Empty or (SingleProc2.EnergyCurrentState= "Working" and
Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2") and SingleProc4.EnergyCurrentState=
"Standby" then SingleProc3.pause:=true; waituntil SingleProc4.EnergyCurrentState="Operational"
and ((SingleProc2.EnergyCurrentState= "Working" and ((SingleProc2.cont.name="Entity2" or
Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2") and
528
(Buffer3.Empty or Buffer3.cont.name="Entity3") and (SingleProc4.EnergyCurrentState= "Working"
(Buffer3.Empty or Buffer3.cont.name="Entity3") and SingleProc4.EnergyCurrentState= "Standby"
then SingleProc3.pause:=true; waituntil SingleProc4.EnergyCurrentState="Operational" prio 1;
(Buffer3.Empty or Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2") and
529
SingleProc2.Empty) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
Buffer2.Empty and (Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.Empty)
530
and SingleProc4.EnergyCurrentState= "Standby" then SingleProc3.pause:=true; waituntil
SingleProc2.ProcTime-SingleProc3.ProcTime)>TT ) and (SingleProc2.cont.remainingProcTime<
SingleProc1.cont.remainingProcTime) and (Buffer1.cont.name="Entity1" or
Buffer1.cont.name="Entity6") and Buffer2.Empty and (Buffer3.cont.name="Entity1" or
Buffer3.cont.name="Entity2" or Buffer3.Empty) and (SingleProc4.EnergyCurrentState= "Working"
SingleProc2.ProcTime-SingleProc3.ProcTime)>TT ) and (SingleProc2.cont.remainingProcTime<
Buffer3.cont.name="Entity2" or Buffer3.Empty) and SingleProc4.EnergyCurrentState= "Standby"
SingleProc1.cont.remainingProcTime) and ((Buffer1.cont.name="Entity2" or
and Buffer2.Empty and (Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or
531
SingleProc1.cont.remainingProcTime) and ((Buffer1.cont.name="Entity2" or
Buffer3.Empty) and SingleProc4.EnergyCurrentState= "Standby" then SingleProc3.pause:=true;
waituntil SingleProc4.EnergyCurrentState="Operational" prio 1; SingleProc3.pause:=false;
SingleProc5.EnergyCurrentState= "Working" and (SingleProc5.cont.name="Entity3" or
SingleProc5.cont.name="Entity4") and (SingleProc5.cont.remainingProcTime-
SingleProc3.ProcTime)>TT and (Buffer1.Empty or (Buffer1.cont.name="Entity2" or
Buffer3.cont.name="Entity2" ) and (SingleProc4.EnergyCurrentState= "Working" or
SingleProc3.ProcTime)>TT and (Buffer1.Empty or (Buffer1.cont.name="Entity2" or
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-SingleProc3.ProcTime)>TT and
SingleProc6.cont.name="Entity5")) and (SingleProc5.cont.remainingProcTime<
532
SingleProc4.EnergyCurrentState= "Operational") then print "M3-vincolo16";
Buffer3.cont.name="Entity3") and SingleProc4.pause=true then SingleProc3.pause:=true; waituntil
533
Buffer3.cont.name="Entity3") and SingleProc4.EnergyCurrentState="Standby" then print "M3-
vincolo17bisbis"; SingleProc3.startPause(SingleProc6.cont.remainingProcTime+
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2") and
SingleProc3.ProcTime)>TT and ((SingleProc5.EnergyCurrentState= "Working" and
534
Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" ) and
SingleProc6.ProcTime-SingleProc3.ProcTime)>TT and ((SingleProc5.EnergyCurrentState=
535
SingleProc6.ProcTime-SingleProc3.ProcTime)>TT and SingleProc5.EnergyCurrentState= "Working"
and ((SingleProc5.cont.name="Entity1" or SingleProc5.cont.name="Entity6") or
(SingleProc5.cont.remainingProcTime< SingleProc6.cont.remainingProcTime) and
Buffer1.cont.name="Entity4") ) and Buffer2.Empty and Buffer3.cont.name="Entity3" and
(SingleProc5.cont.remainingProcTime< SingleProc6.cont.remainingProcTime)) or
(Buffer3.Empty or Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" ) and
536
SingleProc1.ProcTime-SingleProc3.ProcTime)>TT and (SingleProc1.cont.remainingProcTime<
SingleProc2.cont.remainingProcTime) and ((SingleProc5.EnergyCurrentState= "Working" and
SingleProc6.cont.name="Entity6"))) or SingleProc6.Empty) and (Buffer1.cont.name="Entity1" or
SingleProc1.ProcTime-SingleProc3.ProcTime)>TT and (SingleProc1.cont.remainingProcTime<
537
waituntil SingleProc4.EnergyCurrentState="Operational" prio 1; SingleProc3.pause:=false;
Buffer1.Empty) and Buffer2.Empty and (Buffer3.cont.name="Entity1" or
538
SingleProc2.Empty) and (Buffer1.Empty or Buffer1.cont.name="Entity1" or
Buffer1.cont.name="Entity6") and Buffer2.Empty and ( Buffer3.Empty or
Buffer1.cont.name="Entity6") and Buffer2.Empty and (Buffer3.Empty or
539
Buffer1.cont.name="Entity6") and Buffer2.Empty and ( Buffer3.Empty or
((Buffer1.Empty or Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
((Buffer1.Empty or Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
540
541
542
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.Empty) and
543
( Buffer1.Empty or (Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
Buffer3.cont.name="Entity3" and (SingleProc4.EnergyCurrentState= "Working" or
Buffer3.cont.name="Entity3" and SingleProc4.EnergyCurrentState= "Standby" then
544
SingleProc3.ProcTime)>TT and((SingleProc2.EnergyCurrentState= "Working" and
SingleProc1.cont.name="Entity6") and(SingleProc1.cont.remainingProcTime-
SingleProc3.ProcTime)>TT and((SingleProc2.EnergyCurrentState= "Working" and
SingleProc1.cont.name="Entity4") )and (SingleProc1.cont.remainingProcTime+
Buffer2.Empty and (Buffer3.Empty or Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2"
) and (SingleProc4.EnergyCurrentState= "Working" or SingleProc4.EnergyCurrentState=
(Buffer1.Empty or (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6"))and
Buffer2.Empty and (Buffer3.Empty or Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2")
545
546
(Buffer1.Empty or Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty
and (Buffer3.Empty or Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" ) and
547
and (Buffer3.Empty or Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" ) and
SingleProc4.EnergyCurrentState="Operational" prio 1; SingleProc3.pause:=false
548
549
550
and ((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-SingleProc3.ProcTime)> TT) and
Buffer3.cont.name="Entity3") then
SingleProc5.cont.name="Entity5"))) and (SingleProc6.EnergyCurrentState= "Working" and
SingleProc5.cont.remainingProcTime> SingleProc6.cont.remainingProcTime and
Buffer1.Empty) and Buffer2.Empty and (Buffer3.cont.name="Entity3") then
551
Buffer3.con.name= "Entity2" or Buffer3.Empty) then
Buffer1.Empty) and Buffer2.Empty and (Buffer3.cont.name="Entity1" or Buffer3.con.name=
"Entity2" or Buffer3.Empty) then SingleProc3.startPause(SingleProc6.cont.remainingProcTime-
SingleProc3.ProcTime)> TT) and (SingleProc4.EnergyCurrentState= "Operational" or
(Buffer3.Empty or Buffer3.cont.name="Entity3") then
(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc3.ProcTime)> TT and
Buffer1.Empty) and Buffer2.Empty and (Buffer3.cont.name="Entity3") then
552
Buffer3.cont.name="Entity2" or Buffer3.Empty) then
Buffer3.Empty) then
553
Buffer3.Empty) then
SingleProc1.cont.remainingProcTime) and ((SingleProc2.cont.remainingProcTime+
SingleProc2.ProcTime-SingleProc3.ProcTime)> TT) and
Buffer3.Empty) then
554
((SingleProc2.cont.remainingProcTime+ SingleProc2.ProcTime-SingleProc3.ProcTime)>TT)
and(Buffer1.Empty or (Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
Buffer2.Empty and (Buffer3.Empty or Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2"
) and (SingleProc2.cont.remainingProcTime> SingleProc1.cont.remainingProcTime) and
Buffer1.cont.name="Entity4") ) and Buffer2.Empty and (Buffer3.cont.name="Entity3" ) then
SingleProc6.cont.name="Entity5")) and ((SingleProc6.cont.remainingProcTime+
555
((SingleProc1.cont.remainingProcTime+ SingleProc1.ProcTime-SingleProc3.ProcTime)> TT) and
SingleProc2.cont.name="Entity4")) and SingleProc1.cont.remainingProcTime>
SingleProc2.cont.remainingProcTime) or SingleProc2.Empty) and
SingleProc1.cont.remainingProcTime<=SingleProc2.cont.remainingProcTime) or
and SingleProc4.cont.remainingProcTime<=TT)) and (Buffer1.cont.name="Entity1" or
SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime) or SingleProc6.Empty)
(SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime<=TT)) and (
(Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") ) and Buffer2.Empty and (
Buffer3.Empty or Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" ) then
556
(SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime<=TT)) and (
(Buffer3.Empty or Buffer3.cont.name="Entity3") then
SingleProc3.ProcTime)> TT) and ((SingleProc2.cont.name="Entity1" or
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.Empty) then
SingleProc2.cont.name="Entity5")) and ((SingleProc2.cont.remainingProcTime +
Buffer1.cont.name="Entity6")) and Buffer2.Empty and (Buffer3.cont.name="Entity1" or
557
SingleProc3.ProcTime)> TT) and (SingleProc4.EnergyCurrentState="Operational" or
and SingleProc4.cont.remainingProcTime<=TT)) and ( Buffer1.Empty or
Buffer3.cont.name="Entity3" )then
558
Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.Empty) then
559
SingleProc1.cont.name="Entity4"))) and ((SingleProc1.cont.remainingProcTime +
Buffer1.cont.name="Entity6")) and Buffer2.Empty and (Buffer3.cont.name="Entity1" or
SingleProc6.cont.name="Entity5"))) and ((SingleProc6.cont.remainingProcTime+
560
Buffer1.cont.name="Entity4") ) and Buffer2.Empty and (Buffer3.cont.name="Entity3") then
561
SingleProc3.ProcTime)>TT) and ((SingleProc1.cont.name="Entity1" or
SingleProc1.cont.remainingProcTime <= SingleProc2.cont.remainingProcTime and
562
Buffer3.cont.name="Entity3") then
Buffer3.Empty) then
Buffer3.Empty) then
563
SingleProc4.cont.remainingProcTime<=TT))and ( Buffer1.Empty or (Buffer1.cont.name="Entity2" or
and Buffer2.Empty and ( Buffer3.Empty or (Buffer3.cont.name="Entity2" or
Buffer3.Empty) then
564
Buffer3.Empty) then
SingleProc2.cont.name="Entity4") ) ) and
Buffer3.cont.name="Entity6") ) then SingleProc3.startPause(SingleProc2.cont.remainingProcTime +
565
566
(SingleProc6.cont.remainingProcTime < SingleProc5.cont.remainingProcTime) and
567
Buffer3.Empty) and (SingleProc1.cont.remainingProcTime>SingleProc2.cont.remainingProcTime)
568
and ((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)<=
and ((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)>
and (SingleProc4.EnergyCurrentState= "Standby") and ((Buffer1.cont.name="Entity1" or
and (SingleProc4.EnergyCurrentState= "Standby" )and ((Buffer1.cont.name="Entity1" or
569
and
((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)<=SingleProc5.cont.remainingProcTi
me) then SingleProc3.startPause(SingleProc5.cont.remainingProcTime-SingleProc3.ProcTime);
(SingleProc4.EnergyCurrentState="Operational" or (SingleProc4.EnergyCurrentState="Working" ))
me+SingleProc5.ProcTime)) then SingleProc3.startPause(SingleProc5.cont.remainingProcTime +
"Standby") and ((Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")) and Buffer2.Empty
570
ime+SingleProc5.ProcTime)) then SingleProc3.startPause(SingleProc5.cont.remainingProcTime +
SingleProc6.cont.name="Entity4")) and (SingleProc6.cont.remainingProcTime-
me) and (SingleProc4.EnergyCurrentState="Operational" or
SingleProc4.EnergyCurrentState="Working") then
and (SingleProc4.EnergyCurrentState="Operational" or SingleProc4.EnergyCurrentState="Working"
) and ((Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")) and Buffer2.Empty and
571
and (SingleProc4.EnergyCurrentState="Standby") and ((Buffer1.cont.name="Entity1" or
and (SingleProc4.EnergyCurrentState="Standby" ) and ((Buffer1.cont.name="Entity1" or
and
(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc3.ProcTime)>TT) and
SingleProc5.cont.name="Entity5")) and SingleProc6.cont.remainingProcTime<=
SingleProc5.cont.remainingProcTime) or SingleProc5.empty) and (Buffer1.cont.name="Entity1" or
Buffer1.cont.name="Entity6") and Buffer2.empty and Buffer3.cont.name="Entity3" and
ime+ SingleProc6.ProcTime)) and (SingleProc4.EnergyCurrentState= "Operational" or
SingleProc4.EnergyCurrentState="Working" ) then
572
SingleProc5.cont.name="Entity5")))and SingleProc6.cont.remainingProcTime>
Buffer1.cont.name="Entity6") and Buffer2.empty and (Buffer3.cont.name="Entity1" or
Buffer3.cont.name="Entity2" or Buffer3.Empty) and
(Singleproc6.EnergyCurrentState="Working" and ((SingleProc6.cont.name="Entity1" or
SingleProc5.cont.remainingProcTime)) or SingleProc5.empty) and (Buffer1.cont.name="Entity1" or
Buffer1.cont.name="Entity6") and Buffer2.empty and (Buffer3.cont.name="Entity3") and
me+SingleProc6.ProcTime)) and (SingleProc4.EnergyCurrentState= "Operational" or
(Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.empty and
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity3") and
573
Buffer1.cont.name="Entity6") and Buffer2.empty and (Buffer3.cont.name="Entity3") and
me+SingleProc6.ProcTime)) and SingleProc4.EnergyCurrentState="Standby" then
me+SingleProc6.ProcTime)) and SingleProc4.EnergyCurrentState= "Standby" then
Buffer1.cont.name="Entity6") and Buffer2.empty and Buffer3.cont.name="Entity3" and
ime+SingleProc6.ProcTime)) and SingleProc4.EnergyCurrentState= "Standby" then
574
(SingleProc6.cont.name="Entity2" or SingleProc6.cont.name="Entity5"))) or SingleProc6.empty) and
ime)) and (SingleProc4.EnergyCurrentState= "Operational" or
SingleProc3.ProcTime)>TT and ((SingleProc6.EnergyCurrentState="Working" and
me)) and (SingleProc4.EnergyCurrentState= "Operational" or
(Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty and
me)) and SingleProc4.EnergyCurrentState= "Standby" then
575
ime)) and SingleProc4.EnergyCurrentState= "Standby" then
SingleProc5.EnergyCurrentState="Working" and((SingleProc5.cont.name="Entity1" or
SingleProc6.empty) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
Buffer2.Empty and Buffer3.cont.name="Entity3" and
ime+SingleProc5.ProcTime)) and (SingleProc4.EnergyCurrentState= "Operational" or
576
SingleProc5.ProcTime-SingleProc3.ProcTime)>TT and (SingleProc6.EnergyCurrentState="Working"
577
578
ime)) and (SingleProc4.EnergyCurrentState= "Working" or
me)) and (SingleProc4.EnergyCurrentState= "Working" or
579
SingleProc4.EnergyCurrentState= "Working") then
580
581
(SingleProc5.cont.remainingProcTime-SingleProc3.ProcTime)>TT) and
SingleProc6.cont.remainingProcTime) or SingleProc6.Empty) and Buffer3.cont.name="Entity3" and
(SingleProc4.EnergyCurrentState= "Operational" or SingleProc4.EnergyCurrentState="Working")
582
and (Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.Empty) and
(SingleProc4.EnergyCurrentState="Operational" or SingleProc4.EnergyCurrentState="Working")
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity3" or
583
SingleProc3.startPause(SingleProc6.cont.remainingProcTime-SingleProc3.ProcTime;
SingleProc3.ProcTime)>TT) and Buffer3.cont.name="Entity3" and Buffer2.Empty and
(SingleProc4.EnergyCurrentState="Working" or SingleProc4.EnergyCurrentState="Operational" )
584
(SingleProc4.EnergyCurrentState="Working" or SingleProc4.EnergyCurrentState="Operational")
585
SingleProc6.cont.remainingProcTime<SingleProc5.cont.remainingProcTime) or SingleProc5.Empty)
and Buffer3.cont.name="Entity3" and Buffer2.Empty and ((Buffer1.cont.name="Entity2" or
586
SingleProc3.startPause(SingleProc2.cont.remainingProcTime-SingleProc3.ProcTime
(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime-SingleProc3.ProcTime)>TT ) and
ime+SingleProc1.ProcTime)) and (SingleProc4.EnergyCurrentState= "Working" or
me+SingleProc1.ProcTime)) and (SingleProc4.EnergyCurrentState= "Working" or
587
((SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime)>=(SingleProc1.cont.remainingProcT
588
ime+SingleProc5.ProcTime)) and SingleProc4.EnergyCurrentState="Standby" then
589
me+SingleProc5.ProcTime)) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
590
SingleProc2.Empty) and SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime
and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty and
Buffer3.cont.name="Entity3" and
ime+SingleProc6.ProcTime)) and
SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime and
591
SingleProc3.ProcTime)>TT and (SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime-
SingleProc3.ProcTime)>TT) and(SingleProc6.EnergyCurrentState="Working" and
(SingleProc6.cont.name="Entity2" or SingleProc6.cont.name="Entity5")) or SingleProc6.Empty) and
SingleProc3.ProcTime)>TT) and (SingleProc5.cont.remainingProcTime+ SingleProc5.ProcTime-
SingleProc6.Empty) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
Buffer2.Empty and Buffer3.cont.name="Entity3" and (SingleProc4.EnergyCurrentState="Working"
or SingleProc4.EnergyCurrentState="Operational") then
592
Buffer2.Empty and Buffer3.cont.name="Entity3" and SingleProc4.EnergyCurrentState="Standby"
SingleProc2.ProcTime-SingleProc3.ProcTime)>TT) and (SingleProc5.cont.remainingProcTime+
ime+SingleProc5.ProcTime)) and (SingleProc4.EnergyCurrentState="Working" or
(SingleProc5.cont.name="Entity3" or SingleProc5.cont.name="Entity4")) and (Buffer1.Empty or
(Buffer3.Empty or Buffer3.cont.name="Entity3") and(SingleProc2.EnergyCurrentState="Working"
(SingleProc2.cont.remainingProcTime+ SingleProc2.ProcTime-SingleProc3.ProcTime)>TT) and
me+SingleProc5.ProcTime)) and (SingleProc4.EnergyCurrentState="Working" or
593
ime+SingleProc5.ProcTime)) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
594
ime+SingleProc5.ProcTime)) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
595
ime+ SingleProc6.ProcTime)) and (SingleProc4.EnergyCurrentState="Working" or
596
me+ SingleProc6.ProcTime)) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
ime+ SingleProc6.ProcTime)) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")
and Buffer2.Empty and Buffer3.cont.name="Entity3" and
me+ SingleProc6.ProcTime)) and SingleProc4.EnergyCurrentState="Standby" then
597
me+ SingleProc6.ProcTime)) and (SingleProc4.EnergyCurrentState="Working" or
ime+ SingleProc6.ProcTime)) and SingleProc4.EnergyCurrentState="Standby" then
598
SingleProc3.ProcTime)>TT and
Buffer3.cont.name="Entity3") and (SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
SingleProc3.ProcTime)>TT and SingleProc6.EnergyCurrentState="Working" and
(SingleProc6.cont.remainingProcTime-SingleProc3.ProcTime)>TT and
599
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime)<=(SingleProc6.cont.remainingProcTi
me+SingleProc6.ProcTime) and (SingleProc4.EnergyCurrentState="Working" or
Buffer3.cont.name="Entity3" and ((SingleProc2.EnergyCurrentState="Working" and
me+SingleProc6.ProcTime) and SingleProc4.EnergyCurrentState="Standby" then
(SinglePro5.cont.remainingProcTime+SingleProc5.ProcTime)>(SingleProc6.cont.remainingProcTime
+SingleProc6.ProcTime) and (SingleProc4.EnergyCurrentState="Working" or
600
(SinglePro5.cont.remainingProcTime+SingleProc5.ProcTime)>(SingleProc6.cont.remainingProcTime
+SingleProc6.ProcTime) and SingleProc4.EnergyCurrentState="Standby" then
SingleProc3.ProcTime)>TT) and (Buffer1.Empty or (Buffer1.cont.name="Entity2" or
SingleProc3.ProcTime)>TT) and (Buffer1.Empty or (Buffer1.cont.name="Entity2" or
(Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity1" or Buffer3.Empty) and Buffer2.Empty
and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
601
and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
SingleProc2.cont.name="Entity4") ) and (SingleProc2.cont.remainingProcTime+
Buffer3.cont.name="Entity1" or Buffer3.Empty) and Buffer2.Empty and
602
SingleProc2.cont.name="Entity4") )) or SingleProc2.Empty) and
SingleProc3.ProcTime)>TT and (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity1" or
Buffer1.cont.name="Entity6") and
SingleProc3.ProcTime)>TT and (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity1" or
603
SingleProc5.ProcTime-SingleProc3.ProcTime)>TT and (Buffer1.cont.name="Entity1" or
Buffer1.cont.name="Entity6") and Buffer2.Empty and Buffer3.cont.name="Entity3" and
604
SingleProc2.cont.name="Entity4") ) and (SingleProc1.cont.remainingProcTime<=
SingleProc6.cont.remainingProcTime<=SingleProc5.cont.remainingProcTime) or SingleProc5.Empty
) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty and
605
) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
and

606
) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
and
SingleProc2.cont.name="Entity6") and (SingleProc2.cont.remainingProcTime+
SingleProc2.ProcTime-SingleProc3.ProcTime)>TT and (SingleProc2.cont.remainingProcTime-
and (SingleProc4.EnergyCurrentState="Working" or SingleProc4.EnergyCurrentState="Operational")
607
SingleProc5.ProcTime-SingleProc3.ProcTime)>TT) and (Buffer1.cont.name="Entity1" or
608
Buffer1.cont.name="Entity6") and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")
609
SingleProc5.ProcTime-SingleProc3.ProcTime)>TT) and ((Buffer1.cont.name="Entity2" or
Buffer3.cont.name="Entity2" or Buffer3.Empty)and
610
(SingleProc2.EnergyCurrentState="Working" and (SingleProc2.cont.remainingProcTime-
611
612
613
SingleProc2.cont.name="Entity4")))or SingleProc2.Empty) and (Buffer1.Empty or
614
Buffer1.cont.name="Entity4")) and Buffer2.Empty and Buffer3.cont.name="Entity3" and
SingleProc5.cont.name="Entity6"))) and (SingleProc5.cont.remainingProcTime+
SingleProc5.ProcTime-SingleProc3.ProcTime)>TT) and (Buffer1.Empty or
615
SingleProc1.EnergyCurrentState="Working" and (SingleProc1.cont.remainingProcTime-
616
Buffer3.cont.name="Entity2" or Buffer3.Empty) and (SingleProc4.EnergyCurrentState="Working" or
Buffer3.cont.name="Entity2" or Buffer3.Empty) and SingleProc4.EnergyCurrentState="Standby"
SingleProc1.EnergyCurrentState="Working" and (SingleProc1.cont.remainingProcTime+
617
618
SingleProc3.ProcTime)>TT) and (SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
SingleProc6.Empty) and Buffer3.cont.name="Entity3" and Buffer2.Empty and
Buffer1.cont.name="Entity5") or Buffer1.Empty) and (SingleProc4.EnergyCurrentState="Working"
Buffer1.cont.name="Entity5") or Buffer1.Empty) and SingleProc4.EnergyCurrentState="Standby"
619
(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)>(SingleProc5.cont.remainingProcTim
e+SingleProc5.ProcTime) and (SingleProc4.EnergyCurrentState="Working" or
e+SingleProc5.ProcTime) and SingleProc4.EnergyCurrentState="Standby" then
620
621
(SingleProc1.cont.remainingProcTime<=SingleProc6.cont.remainingProcTime)and(SingleProc4.Ener
gyCurrentState="Working" or SingleProc4.EnergyCurrentState="Operational" ) then
622
(SingleProc1.EnergyCurrentState="Working" and
Buffer3.cont.name="Entity3" and Buffer2.Empty and (Buffer1.cont.name="Entity1" or
Buffer1.cont.name="Entity6") and (SingleProc1.cont.remainingProcTime<=
623
(Buffer3.cont.name="Entity1" or (Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
and (SingleProc6.cont.remainingProcTime>SingleProc5.cont.remainingProcTime) and
624
625
SingleProc1.cont.name="Entity4") ) and
626
SingleProc1.cont.name="Entity4") )and
(SingleProc5.cont.remainingProcTime>=SingleProc6.cont.remainingProcTime)) or
and
and
627
and (SingleProc4.EnergyCurrentState="Working" or SingleProc4.EnergyCurrentState="Operational"
628
(SingleProc1.cont.name="Entity3" or SingleProc1.cont.name="Entity4") )) or SingleProc1.Empty)
and (Buffer1.Empty or (Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
629
SingleProc1.cont.name="Entity4") )) or SingleProc1.Empty) and (Buffer1.Empty or
630
Buffer3.cont.name="Entity3" and (SingleProc4.EnergyCurrentState="Working" or
Buffer3.cont.name="Entity3" and SingleProc4.EnergyCurrentState="Standby" then
631
SingleProc5.cont.name="Entity6") )) or SingleProc5.Empty) and (Buffer1.cont.name="Entity1" or
Buffer3.cont.name="Entity2" or Buffer3.Empty) and ((SingleProc2.cont.remainingProcTime+
SingleProc2.ProcTime) <=(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)) and
632
SingleProc2.ProcTime)>(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)) and
SingleProc2.ProcTime)<(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)) and
SingleProc2.ProcTime)>=(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)) and
633
634
635
636
or SingleProc4.EnergyCurrentState="Operational" ) then
637
638
639
640
(SingleProc5.EnergyCurrentState="Working" and (SingleProc5.cont.remainingProcTime+
SingleProc5.cont.name="Entity5"))) and ((SingleProc1.EnergyCurrentState="Working" and
(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime)<=
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime) and
641
(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime-SingleProc3.ProcTime)>TT
and(SingleProc5.EnergyCurrentState="Working" and (SingleProc5.cont.remainingProcTime+
642
643
Buffer2.Empty and (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity3" or Buffer3.Empty
) and
Buffer2.Empty and (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity3" or Buffer3.Empty
) and
Buffer3.cont.name="Entity3" and Buffer2.Empty and ((Buffer1.cont.name="Entity2" or
Buffer1.Empty) and (SingleProc4.EnergyCurrentState="Working" or
644
Buffer1.Empty) and SingleProc4.EnergyCurrentState="Standby" then
Buffer1.Empty) and (SingleProc6.cont.remainingProcTime)<=(SingleProc5.cont.remainingProcTime)
and (SingleProc4.EnergyCurrentState="Working" or
Buffer1.Empty) and (SingleProc6.cont.remainingProcTime)<=(SingleProc5.cont.remainingProcTime)
645
SingleProc1.cont.name="Entity4"))) or SingleProc2.Empty) and Buffer3.cont.name="Entity3" and
and
and
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime)>
646
(SingleProc1.cont.remainingProcTime+SingleProc3.ProcTime)>TT and
Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty and
(Buffer3.Empty or Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity1" or Buffer3.Empty)
647
(SingleProc1.cont.remainingProcTim<=SingleProc2.cont.remainingProcTime) and
648
SingleProc4.EnergyCurrentState="Standby" then SingleProc3.startPause);
SingleProc3.startPause(SingleProc2.cont.remainingProcTime-SingleProc3.ProcTime
649
and
(SingleProc1.cont.remainingProcTime)<=(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTi
me) and (SingleProc4.EnergyCurrentState="Working" or
and
(SingleProc1.cont.remainingProcTime)>(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTim
e) and (SingleProc4.EnergyCurrentState="Working" or
and
me) and SingleProc4.EnergyCurrentState="Standby" then
650
and
e) and SingleProc4.EnergyCurrentState="Standby" then
SingleProc2.Empty ) and Buffer3.cont.name="Entity3" and Buffer2.Empty and
651
((SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc3.ProcTime)>TT )and
Buffer1.Empty ) and (SingleProc6.cont.remainingProcTime<SingleProc5.cont.remainingProcTime)
and
and
652
and
and
653
654
SingleProc3.ProcTime)>TT and (SingleProc2.cont.remainingProcTime+ SingleProc2.ProcTime-
SingleProc3.ProcTime)>TT ) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")
Buffer3.Empty) and (SingleProc2.cont.remainingProcTime<SingleProc1.cont.remainingProcTime)
SingleProc3.ProcTime)>TT ) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5")
or (Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") or Buffer1.Empty) and
SingleProc3.ProcTime)>TT ) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5")
655
SingleProc3.ProcTime)>TT ) and Buffer3.cont.name="Entity3" and Buffer2.Empty and
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime)>=(SingleProc2.cont.remainingProcTi
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime)<(SingleProc2.cont.remainingProcTim
656
((SingleProc1.EnergyCurrentState="Working" and (SingleProc2.EnergyCurrentState="Working" and
me+SingleProc2.ProcTime) and (SingleProc2.cont.name="Entity1" or
(SingleProc2.cont.remainingProcTime<SingleProc1.cont.remainingProcTime)) or
SingleProc1.Empty) and (Buffer3.Empty or Buffer3.cont.name="Entity3") and Buffer2.Empty and
657
658
SingleProc1.Empty) and (SingleProc2.EnergyCurrentState="Working" and
SingleProc6.ProcTime)<=(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime) and
659
SingleProc6.ProcTime)>(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime) and
660
(SingleProc5.EnergyCurrentState="Working" and SingleProc6.EnergyCurrentState="Working") and
SingleProc2.cont.name="Entity4") )) or SingleProc2.Empty) and Buffer3.cont.name="Entity3" and
(SingleProc5.EnergyCurrentState="Working" and SingleProc6.EnergyCurrentState="Working") and
661
SingleProc2.cont.name="Entity4") )) or SingleProc2.Empty) and Buffer3.cont.name="Entity3" and
SingleProc5.cont.name="Entity4"))and((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTim
e-SingleProc3.ProcTime)>TT) and ((SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime-
662
SingleProc5.cont.name="Entity4"))and((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTim
e-SingleProc3.ProcTime)>TT) and ((SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
SingleProc3.ProcTime)>TT) and((SingleProc6.EnergyCurrentState="Working" and
663
SingleProc6.cont.name="Entity4")) and (Buffer1.cont.name="Entity1" or
664
Buffer3.cont.name="Entity3" and (SingleProc6.cont.remainingProcTime<=
665
me+ SingleProc5.ProcTime)) and (SingleProc4.EnergyCurrentState= "Operational" or
666
Buffer3.cont.name="Entity3" and (SingleProc4.EnergyCurrentState= "Operational" or
667
(SingleProc6.cont.remainingProcTime-SingleProc3.ProcTime)>TT and (Buffer1.cont.name="Entity1"
or Buffer1.cont.name="Entity6") and Buffer2.Empty and (Buffer3.cont.name="Entity1" or
Buffer3.cont.name="Entity2" or Buffer3.Empty) and (SingleProc4.EnergyCurrentState="Operational"
or (SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime<=TT))
((Singleproc5.EnergyCurrentState="Working" and ((SingleProc5.cont.name="Entity1" or
668
me) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty and
((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)>SingleProc5.cont.remainingProcTim
e) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty and
669
SingleProc5.cont.name="Entity5")))or SingleProc5.Empty) and (Buffer1.cont.name="Entity1" or
Buffer3.cont.name="Entity2" or Buffer3.Empty) and (SingleProc1.cont.remainingProcTime<=
cTime+SingleProc6.ProcTime)) and (SingleProc4.EnergyCurrentState= "Operational" or
670
me) and (SingleProc4.EnergyCurrentState= "Operational" or
e) and (SingleProc4.EnergyCurrentState= "Operational" or
671
Buffer2.empty and Buffer3.cont.name="Entity3" and
672
Buffer2.empty and Buffer3.cont.name="Entity3" and
SingleProc3.startPause(SingleProc6.cont.remainingProcTime+SinglePro6.ProcTime-
SingleProc5.ProcTime-SingleProc3.ProcTime)>TT) and (SingleProc6.cont.remainingProcTime<=
SingleProc5.cont.remainingProcTime) and (Buffer1.Empty or Buffer1.cont.name="Entity1" or
Buffer3.cont.name="Entity3") and (SingleProc4.EnergyCurrentState= "Operational" or
673
(SingleProc6.cont.remainingProcTime)>(SingleProc5.cont.remainingProcTime) and
(SingleProc1.cont.remainingProcTime)<=(SingleProc2.cont.remainingProcTime) and
SingleProc2.cont.name="Entity4"))) and (Buffer1.cont.name="Entity1" or
me+ SingleProc1.ProcTime) and (SingleProc4.EnergyCurrentState= "Operational" or
674
e+ SingleProc1.ProcTime) and (SingleProc4.EnergyCurrentState= "Operational" or
cTime+ SingleProc5.ProcTime)) and (SingleProc4.EnergyCurrentState= "Operational" or
675
and((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)<(SingleProc5.cont.remainingPro
cTime+ SingleProc5.ProcTime)) and (SingleProc4.EnergyCurrentState= "Operational" or
676
(SingleProc2.cont.remainingProcTime-SingleProc3.ProcTime)>TT ) and
SingleProc3.ProcTime)>TT ) and (SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
SingleProc3.ProcTime)>TT and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
677
678
((SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime-SingleProc3.ProcTime)>TT ) and
679
680
SingleProc1.cont.name="Entity6")) and ((Buffer1.cont.name="Entity2" or
Buffer3.cont.name="Entity2" or Buffer3.Empty) and (SingleProc4.EnergyCurrentState=
Buffer3.cont.name="Entity2" or Buffer3.Empty) and (SingleProc2.cont.remainingProcTime<=
SingleProc1.cont.remainingProcTime) and (SingleProc4.EnergyCurrentState= "Operational" or
681
SingleProc1.cont.name="Entity6")) and ((Buffer1.cont.name="Entity2" or
Buffer1.Empty) and Buffer2.Empty and Buffer3.cont.name="Entity3" and
682
(Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity1" or Buffer3.Empty ) and
(Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity1" or Buffer3.Empty ) and
683
me+SingleProc6.ProcTime)) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
Buffer2.Empty and Buffer3.cont.name="Entity3" and (SingleProc4.EnergyCurrentState=
me+SingleProc6.ProcTime)) and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5")
and (Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") and Buffer1.Empty) and
(Buffer2.Empty) and (Buffer3.cont.name="Entity1" and Buffer3.cont.name="Entity2" and
Buffer3.Empty) and (SingleProc4.EnergyCurrentState= "Operational" or
684
((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") and (Buffer1.cont.name="Entity3"
or Buffer1.cont.name="Entity4") and Buffer1.Empty) and (Buffer2.Empty) and
(Buffer3.cont.name="Entity1" and Buffer3.cont.name="Entity2" and Buffer3.Empty) and
ime+SingleProc5.ProcTime)) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")
and Buffer2.Empty and Buffer3.cont.name="Entity3" and (SingleProc4.EnergyCurrentState=
ime+SingleProc5.ProcTime))and ((SingleProc1.EnergyCurrentState="Working" and
685
686
SingleProc1.cont.name="Entity4"))) or SingleProc1.Empty) and ( Buffer1.Empty or
"Operational" or SingleProc4.EnergyCurrentState="Working") then
SingleProc3.ProcTime)>TT and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
687
SingleProc5.cont.name="Entity4"))and(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime
-SingleProc3.ProcTime)>TT and (SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
688
SingleProc3.ProcTime)>TT ) and
SingleProc3.ProcTime)>TT) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
and (SingleProc1.cont.remainingProcTime<= SingleProc2.cont.remainingProcTime) and
SingleProc5.cont.name="Entity4"))and(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime
-SingleProc3.ProcTime)>TT and (SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-
SingleProc3.ProcTime)>TT and (SingleProc5.EnergyCurrentState="Working" and
(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc3.ProcTime)>TT )) and
689
SingleProc3.ProcTime)>TT) and (Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity1" or
690
(SingleProc1.cont.remainingProcTim>SingleProc2.cont.remainingProcTime) and
691
692
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-SingleProc3.ProcTime)>TT) or
(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.Empty )and
Buffer1.Empty )and (SingleProc4.EnergyCurrentState= "Operational" or
693
SingleProc2.cont.name="Entity6") and (SingleProc2.cont.remainingProcTime-SingleProc3.ProcTime
)>TT) and (SingleProc1.cont.remainingProcTim<=SingleProc2.cont.remainingProcTime) and
(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime-SingleProc3.ProcTime )>TT) and
694
SingleProc2.ProcTime-SingleProc3.ProcTime )>TT) and Buffer3.cont.name="Entity3" and
Buffer2.Empty and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
SingleProc3.ProcTime); --156 156 elseif (SingleProc1.EnergyCurrentState="Working" and
SingleProc2.cont.remainingProcTime))or SingleProc2.Empty) and Buffer3.cont.name="Entity3" and
SingleProc3.ProcTime)>TT and Buffer3.cont.name="Entity3" and Buffer2.Empty and
Buffer1.cont.name="Entity4") or Buffer1.Empty )and (SingleProc4.EnergyCurrentState=
695
696
(Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")
and(SingleProc2.cont.remainingProcTime<=SingleProc1.cont.remainingProcTime) and
697
Buffer1.cont.name="Entity" and (SingleProc4.EnergyCurrentState="Operational" or
Buffer1.Empty) and (SingleProc4.EnergyCurrentState="Operational" or
698
Buffer1.cont.name="Entity6") and (SingleProc4.EnergyCurrentState="Operational" or
and(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime-SingleProc3.ProcTime)>TT and
(SingleProc4.EnergyCurrentState="Working" and SingleProc4.cont.remainingProcTime<=TT )) then
and(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity2" or Buffer3.Empty) and
SingleProc4.cont.remainingProcTime<=TT )) then
699
and(SingleProc2.cont.remainingProcTime<SingleProc1.cont.remainingProcTime) and
700
SingleProc3.ProcTime); else SingleProc3.EnergyCurrentState:="Operational";
end;
end;
is
do
while (true) loop
else
DurationStandby3:=DurationStandby3;
end;
wait (1);
end;
end;
is
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
do
@.Op := @.Op+1;
@.move(root.drain);
end;
if Buffer2.empty and Buffer22.empty=false thenSingleProc4.EnergyCurrentState:="Operational";

SingleProc3.cont.remainingProcTime=0 then SingleProc4.EnergyCurrentState:="Standby";
(SingleProc1.cont.name="Entity1" or SingleProc1.cont.name="Entity6") and Buffer2.Empty and
Buffer22.Empty and SingleProc2.Empty and SingleProc5.Empty and SingleProc6.Empty then
701
((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or Buffer1.cont.name="Entity5") or
Buffer3.cont.name= "Entity2" or Buffer3.Empty) and (SingleProc3.EnergyCurrentState= "Working"
(Buffer3.Empty or(Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity6") or
Buffer3.cont.name= "Entity2" ) and SingleProc3.EnergyCurrentState= "Standby" then
SingleProc6.Empty) and (Buffer1.Empty or ((Buffer1.cont.name="Entity2" or
Buffer1.cont.name="Entity5") or Buffer1.cont.name="Entity5") or (Buffer1.cont.name="Entity3" or
702
(SingleProc5.cont.remainingProcTime>SingleProc6.cont.remainingProcTime) and( Buffer1.Empty or
703
(SingleProc5.cont.name= "Entity2" or (SingleProc5.cont.name="Entity1" or
(Buffer1.Empty or ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
"Operational") then SingleProc4.startPause(SingleProc6.cont.remainingProcTime-
704
SingleProc5.cont.name="Entity6")) and (SingleProc6.cont.remainingProcTime>
705
SingleProc5.cont.remainingProcTime) and (SingleProc5.cont.remainingProcTime+
and Buffer2.Empty and (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") and
"Working" and (SingleProc5.cont.name= "Entity2" or (SingleProc5.cont.name="Entity1" or
then SingleProc4.startPause(SingleProc1.cont.remainingProcTime+ SingleProc1.ProcTime–
706
(SingleProc2.cont.remainingProcTime+ SingleProc2.ProcTime-SingleProc4.ProcTime)>TT ) and
SingleProc4.startPause(SingleProc2.cont.remainingProcTime+ SingleProc2.ProcTime–
(SingleProc2.cont.remainingProcTime+ SingleProc2.ProcTime-SingleProc4.ProcTime)>TT ) and
(((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or Buffer1.cont.name="Entity5") or
SingleProc4.startPause(SingleProc1.cont.remainingProcTime+ SingleProc1.ProcTime–
707
SingleProc4.ProcTime)>TT and ( Buffer1.Empty or ((Buffer1.cont.name="Entity2" or
SingleProc4.ProcTime)>TT and (Buffer1.Empty or ((Buffer1.cont.name="Entity2" or
SingleProc5.cont.name="Entity6") or SingleProc5.cont.name= "Entity2") and
708
SingleProc3.EnergyCurrentState= "Standby" then print "M4-vincolo16bis"; SingleProc4.pause:=true;
SingleProc4.ProcTime); print "M4-vincolo17";
SingleProc3.pause=true then print "M4-vincolo17bis"; SingleProc4.pause:=true; waituntil
709
SingleProc3.EnergyCurrentState="Standby" then print "M4-vincolo17bisbis";
"Operational") then print "M4-vincolo18";
710
then print "M4-vincolo19"; SingleProc4.startPause(SingleProc6.cont.remainingProcTime-
elseif Buffer2.Empty and SingleProc2.EnergyCurrentState= "Working" and
711
and (Buffer3.Empty or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4")) and
then print "M4-vincolo21"; SingleProc4.startPause(SingleProc5.cont.remainingProcTime+
then print "M4-vincolo22"; SingleProc4.startPause(SingleProc6.cont.remainingProcTime+
712
SingleProc1.ProcTime–SingleProc4.ProcTime)>TT and (SingleProc1.cont.remainingProcTime<
Buffer1.cont.name="Entity6") and Buffer2.Empty and ((Buffer3.cont.name="Entity1" or
SingleProc1.ProcTime–SingleProc4.ProcTime)>TT and (SingleProc1.cont.remainingProcTime<
713
SingleProc6.cont.name="Entity6"))) or SingleProc6.Empty) and (((Buffer1.cont.name="Entity2" or
714
SingleProc4.startPause(SingleProc1.cont.remainingProcTime–SingleProc4.ProcTime);
715
SingleProc4.startPause(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime–
"Operational") then
SingleProc4.startPause(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime–
716
717
718
719
SingleProc3.EnergyCurrentState= "Operational" prio 1; SingleProc4.pause:=false; -
( Buffer1.Empty or ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
720
then SingleProc4.EnergyCurrentState:="Standby";
721
Buffer2.Empty and ( Buffer3.Empty or (Buffer3.cont.name="Entity1" or
722
723
724
725
726
and SingleProc3.cont.remainingProcTime<=TT)) and (((Buffer1.cont.name="Entity2" or
727
SingleProc5.cont.name="Entity5"))) and (SingleProc6.EnergyCurrentState= "Working" and
SingleProc5.cont.remainingProcTime> SingleProc6.cont.remainingProcTime and
Buffer3.Empty) then
728
SingleProc4.ProcTime)> TT) and (SingleProc3.EnergyCurrentState= "Operational" or
(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc3.ProcTime)> TT and
729
Buffer3.Empty) then
Buffer3.Empty) then
730
Buffer3.Empty) then
((SingleProc2.cont.remainingProcTime+ SingleProc2.ProcTime-SingleProc4.ProcTime)> TT) and (
Buffer1.Empty or ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
731
and (SingleProc2.cont.remainingProcTime> SingleProc1.cont.remainingProcTime) and
(Buffer3.Empty or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") ) then
SingleProc6.cont.name="Entity5")) and ((SingleProc6.cont.remainingProcTime+
732
SingleProc2.cont.name="Entity4")) and SingleProc1.cont.remainingProcTime>
SingleProc2.cont.remainingProcTime) or SingleProc2.Empty) and
Buffer3.Empty) then
733
and Buffer2.Empty and (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") then
SingleProc2.EnergyCurrentState="Working" and SingleProc6.EnergyCurrentState="Working" and
SingleProc4.ProcTime)> TT) and SingleProc2.EnergyCurrentState="Working" and
((SingleProc2.cont.name="Entity1" or SingleProc2.cont.name="Entity6")) and
734
SingleProc4.ProcTime)> TT) and (SingleProc3.EnergyCurrentState="Operational" or
(Buffer3.Empty or (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") )then
735
Buffer3.Empty) then
736
SingleProc4.ProcTime)>TT) and((SingleProc6.EnergyCurrentState="Working" and
Buffer3.Empty) then
737
738
SingleProc1.cont.remainingProcTime <= SingleProc2.cont.remainingProcTime and
Buffer3.Empty) then
739
SingleProc3.cont.remainingProcTime<=TT)) and (Buffer1.Empty or ((Buffer1.cont.name="Entity2"
or Buffer1.cont.name="Entity5") or Buffer1.cont.name="Entity5") or (Buffer1.cont.name="Entity3"
Buffer3.Empty) then
740
SingleProc3.cont.remainingProcTime<=TT)) and (((Buffer1.cont.name="Entity2" or
SingleProc3.cont.remainingProcTime<=TT))and (Buffer1.Empty or ((Buffer1.cont.name="Entity2"
or Buffer1.cont.name="Entity4") ) and Buffer2.Empty and (Buffer3.Empty
or(Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity5") or (Buffer3.cont.name="Entity1" or
741
Buffer3.Empty) then
742
743
(SingleProc6.cont.remainingProcTime < SingleProc5.cont.remainingProcTime) and
Buffer1.cont.name="Entity4") or Buffer1.Empty ) and Buffer2.Empty and (Buffer3.Empty or
744
745
and ((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)<=
746
and (SingleProc3.EnergyCurrentState= "Standby") and ((Buffer1.cont.name="Entity1" or
and (SingleProc3.EnergyCurrentState= "Standby" )and ((Buffer1.cont.name="Entity1" or
and
(SingleProc3.EnergyCurrentState="Operational" or (SingleProc3.EnergyCurrentState="Working" ))
747
ime+SingleProc5.ProcTime)) then SingleProc4.startPause(SingleProc5.cont.remainingProcTime +
748
and (SingleProc3.EnergyCurrentState="Operational" or SingleProc3.EnergyCurrentState="Working"
) and ((Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")) and Buffer2.Empty and
and (SingleProc3.EnergyCurrentState="Standby") and ((Buffer1.cont.name="Entity1" or
and (SingleProc3.EnergyCurrentState="Standby" ) and ((Buffer1.cont.name="Entity1" or
and
749
SingleProc5.cont.remainingProcTime) or SingleProc5.empty) and (Buffer1.cont.name="Entity1" or
SingleProc5.cont.name="Entity5")))and SingleProc6.cont.remainingProcTime>
Buffer1.cont.name="Entity6") and Buffer2.empty and ((Buffer3.cont.name="Entity1" or
and
Buffer3.cont.name="Entity4")) and (SingleProc1.cont.remainingProcTime<=
750
Buffer3.cont.name="Entity4")) and (SingleProc1.cont.remainingProcTime<=
751
752
753
754
755
ime)) and (SingleProc3.EnergyCurrentState= "Working" or
756
757
758
759
SingleProc6.cont.remainingProcTime) or SingleProc6.Empty) and (Buffer3.cont.name="Entity3" or
Buffer3.cont.name="Entity4") and Buffer2.Empty and (((Buffer1.cont.name="Entity2" or
Buffer1.cont.name="Entity4") or Buffer1.Empty) and (SingleProc4.EnergyCurrentState=
760
Buffer2.Empty and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
Buffer3.Empty) and Buffer2.Empty and (((Buffer1.cont.name="Entity2" or
761
and (SingleProc3.EnergyCurrentState="Working" or SingleProc3.EnergyCurrentState="Operational"
762
763
SingleProc6.cont.remainingProcTime<SingleProc5.cont.remainingProcTime) or SingleProc5.Empty)
Buffer1.Empty) and (SingleProc3.EnergyCurrentState= "Operational" or
764
Buffer3.Empty) and
Buffer3.Empty) and
765
Buffer3.Empty) and
Buffer3.Empty) and
766
767
me+SingleProc5.ProcTime)) and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
768
769
ime+SingleProc6.ProcTime)) and
(SingleProc6.cont.name="Entity2" or SingleProc6.cont.name="Entity5")) or SingleProc6.Empty)and
770
SingleProc6.Empty) and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
Buffer3.cont.name="Entity4") and (SingleProc3.EnergyCurrentState="Working" or
Buffer3.cont.name="Entity4") and SingleProc3.EnergyCurrentState="Standby" then
SingleProc2.ProcTime-SingleProc4.ProcTime)>TT) and (SingleProc5.cont.remainingProcTime+
771
--
(SingleProc2.cont.remainingProcTime<= SingleProc1.cont.remainingProcTime) and (Buffer1.Empty
772
ime+SingleProc5.ProcTime)) and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5")
or Buffer1.Empty) and Buffer2.Empty and (Buffer3.cont.name="Entity3" or
ime+SingleProc5.ProcTime)) and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5")
or Buffer1.Empty) and Buffer2.Empty and (Buffer3.cont.name="Entity3" or
773
774
and (Buffer3.Empty or Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") and
me+ SingleProc6.ProcTime)) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
775
ime+ SingleProc6.ProcTime)) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")
and (Buffer3.Empty or Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") and
776
777
778
Buffer3.cont.name="Entity4")) and ((SingleProc2.EnergyCurrentState="Working" and
Buffer3.cont.name="Entity4") and ((SingleProc2.EnergyCurrentState="Working" and
SingleProc4.ProcTime)>TT) and (Buffer1.Empty or ((Buffer1.cont.name="Entity2" or
779
SingleProc4.ProcTime)>TT) and (Buffer1.Empty or ((Buffer1.cont.name="Entity2" or
780
781
782
783
784
) and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
Buffer3.Empty) and
) and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
Buffer3.Empty) and
785
and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
786
787
788
SingleProc5.ProcTime-SingleProc4.ProcTime)>TT) and (((Buffer1.cont.name="Entity2" or
Buffer3.cont.name="Entity5") or Buffer3.Empty)and
789
790
791
792
793
SingleProc5.ProcTime-SingleProc4.ProcTime)>TT)) and (Buffer1.Empty or
794
795
SingleProc1.cont.remainingProcTime) and (SingleProc3.EnergyCurrentState="Working" or
796
SingleProc1.cont.remainingProcTime) and SingleProc3.EnergyCurrentState="Standby" then
Buffer3.Empty) and
Buffer3.Empty) and
797
Buffer3.Empty) and
798
799
and
and
800
and
and
801
802
803
((Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") or ((Buffer1.cont.name="Entity2" or
Buffer1.cont.name="Entity5") or Buffer1.cont.name="Entity5") or Buffer1.Empty ) and
804
805
806
Buffer3.Empty) and
Buffer3.Empty) and
807
808
and (Buffer1.Empty OR ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
and (Buffer1.Empty OR ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
809
810
and (Buffer1.Empty or ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
and (Buffer1.Empty or ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
811
Buffer3.Empty) and ((SingleProc2.cont.remainingProcTime+ SingleProc2.ProcTime)
<=(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)) and
812
Buffer3.Empty) and ((SingleProc2.cont.remainingProcTime+
SingleProc2.ProcTime)>(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)) and
SingleProc2.ProcTime)<(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)) and
SingleProc2.ProcTime)>=(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime)) and
Buffer1.cont.name="Entity5") or Buffer1.cont.name="Entity5") or Buffer1.Empty) and
813
814
815
816
817
818
and
819
and
and
and
820
Buffer2.Empty and (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4")
821
and(SingleProc5.EnergyCurrentState="Working" and (SingleProc5.cont.remainingProcTime+
822
823
Buffer3.Empty ) and
Buffer3.Empty ) and
824
825
826
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime)>
(SingleProc1.cont.remainingProcTime+SingleProc4.ProcTime)>TT and
SingleProc2.cont.remainingProcTime)) or SingleProc2.Empty) and (Buffer1.cont.name="Entity1" or
827
828
829
830
SingleProc2.Empty ) and (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") and
831
(SingleProc6.EnergyCurrentState="Working") and SingleProc6.cont.remainingProcTime<=TT and
832
(Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") or Buffer1.Empty ) and
833
834
SingleProc4.ProcTime)>TT ) and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5")
835
SingleProc4.ProcTime)>TT ) and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5")
and Buffer2.Empty and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
and
836
and
and
and
SingleProc4.startPause(SingleProc2.cont.remainingProcTime-SingleProc4.ProcTime); -- elseif
837
SingleProc1.Empty) and (SingleProc2.EnergyCurrentState="Working" and
838
and
and
and
839
and Buffer2.Empty and (Buffer1.Empty or ((Buffer1.cont.name="Entity2" or

Buffer2.Empty and (Buffer1.Empty or Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")
and (SingleProc6.cont.remainingProcTime<SingleProc5.cont.remainingProcTime) and
840
841
842
843
844
and
and
(SingleProc6.cont.remainingProcTime<= SingleProc5.cont.remainingProcTime)
and(SingleProc1.cont.remainingProcTime<= SingleProc2.cont.remainingProcTime) and
845
me+ SingleProc5.ProcTime)) and (SingleProc3.EnergyCurrentState= "Operational" or
846
and
and
847
848
(SingleProc6.cont.remainingProcTime-SingleProc4.ProcTime)>TT and (Buffer1.cont.name="Entity1"
or Buffer1.cont.name="Entity6") and Buffer2.Empty and ((Buffer3.cont.name="Entity1" or
849
me) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty and
e) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and Buffer2.Empty and
850
and
851
and
me) and (SingleProc3.EnergyCurrentState= "Operational" or
and
e) and (SingleProc3.EnergyCurrentState= "Operational" or
852
Buffer2.empty and (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") and
853
Buffer2.empty and (Buffer3.cont.name="Entity3" or Buffer3.cont.name="Entity4") and
SingleProc4.startPause(SingleProc6.cont.remainingProcTime+SinglePro6.ProcTime-
SingleProc5.cont.remainingProcTime) and (Buffer1.Empty or Buffer1.cont.name="Entity1" or
854
(SingleProc6.cont.remainingProcTime)>(SingleProc5.cont.remainingProcTime) and
Buffer3.Empty) and
Buffer3.Empty) and
855
Buffer3.Empty) and
856
857
(SingleProc2.cont.remainingProcTime-SingleProc4.ProcTime)>TT ) and
SingleProc4.ProcTime)>TT and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
858
859
SingleProc4.ProcTime)>TT and (((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or
860
(SingleProc3.EnergyCurrentState="Working" and SingleProc3.cont.remainingProcTime<=TT))
861
SingleProc1.cont.name="Entity6")) and (((Buffer1.cont.name="Entity2" or
862
SingleProc1.cont.name="Entity6")) and (((Buffer1.cont.name="Entity2" or
863
(Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") or Buffer1.Empty)and Buffer2.Empty
(Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") or Buffer1.Empty)and Buffer2.Empty
864
865
and Buffer1.Empty) and (Buffer2.Empty) and ((Buffer3.cont.name="Entity1" or
and Buffer3.Empty) and (SingleProc3.EnergyCurrentState= "Operational" or
(((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or Buffer1.cont.name="Entity5")
and (Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") and Buffer1.Empty) and
(Buffer2.Empty) and ((Buffer3.cont.name="Entity1" or Buffer3.cont.name="Entity6") and
(Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity5") and Buffer3.Empty) and
ime+SingleProc5.ProcTime)) and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6")
866
ime+SingleProc5.ProcTime))and ((SingleProc1.EnergyCurrentState="Working" and
SingleProc1.Empty)and (Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity6") and
867
SingleProc1.cont.name="Entity4"))) or SingleProc1.Empty) and ((Buffer1.Empty or
(Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity5") or Buffer1.cont.name="Entity5") or
and(SingleProc1.cont.remainingProcTime<=SingleProc2.cont.remainingProcTime) and
868
869
SingleProc4.ProcTime)>TT )) and
870
(SingleProc6.cont.remainingProcTime+SingleProc6.ProcTime-SingleProc4.ProcTime)>TT )) and
871
SingleProc4.ProcTime)>TT )and
SingleProc4.ProcTime)>TT) and ((Buffer3.cont.name="Entity2" or Buffer3.cont.name="Entity5") or
872
(SingleProc1.cont.remainingProcTim>SingleProc2.cont.remainingProcTime) and
873
(SingleProc5.cont.remainingProcTime+SingleProc5.ProcTime-SingleProc4.ProcTime)>TT) or
874
Buffer3.cont.name="Entity5") or Buffer3.Empty )and (SingleProc3.EnergyCurrentState=
(Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity4") or Buffer1.Empty )and
875
(SingleProc2.cont.remainingProcTime+SingleProc2.ProcTime-SingleProc4.ProcTime )>TT) and
SingleProc2.ProcTime-SingleProc4.ProcTime )>TT) and (Buffer3.cont.name="Entity3" or
SingleProc2.cont.remainingProcTime))or SingleProc2.Empty) and (Buffer3.cont.name="Entity3" or
876
877
878
879
880
and(SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime-SingleProc4.ProcTime)>TT and
881
(SingleProc3.EnergyCurrentState="Operational" or SingleProc3.EnergyCurrentState="Working" )
(SingleProc1.cont.name="Entity2" or SingleProc1.cont.name="Entity5") ))) and
882
(SingleProc6.cont.name="Entity2" or SingleProc6.cont.name="Entity5") ))) then
SingleProc4.EnergyCurrentState:="Standby" ; else SingleProc4.EnergyCurrentState:="Operational";
end;
end;
is
do
while (true) loop
end;
wait (1);
end;
end;
A.2.3.4 Stage C- routing phase and exit control

is
target: object;
do
if SingleProc5.pause=true and SingleProc6.pause=true then
waituntil (SingleProc6.pause=false or SingleProc5.pause=false) prio 1;
@.move;
elseif SingleProc1.Empty and SingleProc2.Empty and SingleProc3.Empty and SingleProc6.Empty
and Buffer1.Empty and Buffer2.Empty and Buffer11.Empty and Buffer22.Empty and
Buffer33.Empty and SingleProc6.EnergyCurrentState="Standby" and
SingleProc5.pause=true then
elseif Buffer33.empty and SingleProc5.EnergyCurrentState="Operational" and

elseif Buffer33.empty and SingleProc5.EnergyCurrentState="Operational" and

Buffer33.Empty then
883
Buffer33.Empty then

elseif SingleProc5.pause=true and SingleProc6.pause=true then
waituntil SingleProc6.pause=false prio 1;


then
elseif SingleProc5.EnergyCurrentState="Operational" and SingleProc6.EnergyCurrentState= "Standby"
then
elseif SingleProc5.EnergyCurrentState="Working" and SingleProc6.EnergyCurrentState="Standby" and
SingleProc5.cont.remainingProcTime <= TT then
elseif SingleProc5.EnergyCurrentState="Working" and SingleProc6.EnergyCurrentState="Standby" and
SingleProc5.cont.remainingProcTime > TT then
884
end;
@.move(target);
else
@.move;
end;
end;
is
Entity1:string;
Entity2:string;
Entity3:string;
Entity4:string;
Entity5:string;
Entity6:string;
do
@.Op := @.Op+1;
@.move(root.drain);
end;
if Buffer3.Empty and Buffer33.Empty and Buffer1.Empty and (Buffer11.Empty or

Buffer11.cont.name="Entity3") and SingleProc3.EnergyCurrentState="Standby"and
SingleProc4.EnergyCurrentState="Standby" and SingleProc6.EnergyCurrentState="Standby"and
SingleProc2.EnergyCurrentState="Standby" and SingleProc1.EnergyCurrentState="Working"and
SingleProc1.cont.remainingProcTime<=TT then
elseif Buffer3.Empty and
885
SingleProc2.cont.name="Entity5") ))) then
elseif SingleProc6.EnergyCurrentState="Standby" and SingleProc3.EnergyCurrentState="Standby" and

SingleProc4.EnergyCurrentState="Standby" and SingleProc1.EnergyCurrentState="Standby" and
Buffer3.Empty and Buffer2.Empty and Buffer1.Empty and Buffer33.Empty then

SingleProc5.ProcTime)>TT) and SingleProc1.cont.name=" Entity2" and
SingleProc5.pause:=true; Waituntil SingleProc6.EnergyCurrentState="Operational" prio 1;
886
SingleProc6.EnergyCurrentState= "Standby" then SingleProc5.pause:=true; Waituntil
"Operational") then
and SingleProc6.EnergyCurrentState= "Standby" then SingleProc5.pause:=true; Waituntil
887
Buffer2.cont.name="Entity4") ) and Buffer3.Empty and ( Buffer1.Empty or Buffer1.Empty or
888
"Operational") then
889
890
891
892
SingleProc2.cont.remainingProcTime))or SingleProc2.Empty) and (Buffer2.Empty or
SingleProc3.cont.name="Entity2"))) or SingleProc3.Empty) and (SingleProc2.Empty
or((SingleProc2.EnergyCurrentState= "Working" and ((SingleProc2.cont.name="Entity4" or
SingleProc2.cont.remainingProcTime))) and (Buffer2.Empty or (Buffer2.cont.name="Entity2" or
893
(SingleProc4.cont.name="Entity4" or SingleProc4.cont.name="Entity5")
andSingleProc1.EnergyCurrentState= "Working" and
"Operational") then
and SingleProc6.pause=true then SingleProc5.pause:=true; Waituntil
894
SingleProc3.cont.name="Entity2"))) orSingleProc3.Empty) and (((SingleProc1.EnergyCurrentState=
895
896
"Operational") then
897
"Operational") then
898
"Operational") then
SingleProc5.ProcTime)>TT)) and ((SingleProc2.EnergyCurrentState= "Working" and
899
SingleProc5.ProcTime)>TT))and ((SingleProc2.EnergyCurrentState= "Working" and
SingleProc4.Empty) and ( Buffer2.Empty or (Buffer2.cont.name="Entity3" or
900
(SingleProc4.cont.remainingProcTime< SingleProc3.cont.remainingProcTime)) and
SingleProc5.ProcTime)>TT)and(SingleProc4.cont.remainingProcTime<
SingleProc3.cont.remainingProcTime))and ((SingleProc2.EnergyCurrentState= "Working" and

901
SingleProc4.cont.name="Entity6"))) and(SingleProc4.cont.remainingProcTime<
Waituntil SingleProc6.EnergyCurrentState="Operational" prio 1; SingleProc5.pause:=false;
902
903
904
905
906
SingleProc4.cont.remainingProcTime))or SingleProc4.Empty)and ((SingleProc1.EnergyCurrentState=
"Operational") then
907
SingleProc4.cont.name="Entity2")))or SingleProc4.Empty) and ((SingleProc1.EnergyCurrentState=
(SingleProc3.cont.name="Entity1" or SingleProc3.cont.name="Entity2")))or SingleProc3.Empty)and
908
909
then SingleProc5.pause:=true; Waituntil SingleProc6.EnergyCurrentState="Operational" prio 1;
SingleProc3.cont.name="Entity2")) and (SingleProc3.cont.remainingProcTime <=
910
911
(Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6")or Buffer2.Empty) and Buffer3.Empty
912
and SingleProc6.cont.remainingProcTime<=TT))and (Buffer3.Empty) and (Buffer2.Empty or
Buffer2.cont.name="Entity6") ) and ((Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity4")
or (Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity5") or Buffer1.Empty) then
and SingleProc6.cont.remainingProcTime<=TT))and ((Buffer2.cont.name="Entity2" or
913
Buffer1.cont.name="Entity4") or Buffer1.cont.name= "Entity3" or Buffer1.Empty) then
SingleProc5.startPause(SingleProc2.cont.remainingProcTime-SingleProc5.ProcTime); -- elseif
914
Buffer1.cont.name="Entity4") or Buffer1.cont.name= "Entity3" or Buffer1.Empty) then
Buffer1.Empty) then
and Buffer3.Empty and ((Buffer1.cont.name="Entity1" or Buffer1.cont.name="Entity4")or
915
Buffer1.Empty) then
Buffer1.Empty) then
SingleProc4.EnergyCurrentState="Working"
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-SingleProc5.ProcTime)> TT) and
Buffer1.Empty) then
916
Buffer1.Empty) then
917
Buffer1.Empty) then
Buffer1.Empty) then
918
Buffer1.Empty) then
Buffer1.Empty) then
919
Buffer1.Empty) then

SingleProc5.ProcTime)> TT)and ((SingleProc4.EnergyCurrentState="Working" and
elseif SingleProc3.EnergyCurrentState="Working" and
SingleProc3.cont.name="Entity5") and SingleProc2.EnergyCurrentState="Working" and
SingleProc2.cont.name="Entity6") and (SingleProc1.EnergyCurrentState="Working" and
((SingleProc1.cont.name="Entity1" or SingleProc1.cont.name="Entity2")or
920
Buffer1.Empty) then
(SingleProc2.cont.remainingProcTime> SingleProc1.cont.remainingProcTime)) ) and
921
Buffer1.Empty) then
922
Buffer1.Empty) then
923
Buffer1.Empty) then
924
Buffer1.Empty) then
925
Buffer1.Empty) then
926
927
Buffer1.Empty) then
928
929
Buffer1.Empty) then
Buffer1.Empty) then
930
931
Buffer1.cont.name="Entity5") or Buffer1.Empty) and (SingleProc3.cont.remainingProcTime>
932
and
933
SingleProc2.cont.name="Entity5")))and (SingleProc1.cont.remainingProcTime>=
934
and
935
and
936
and
and (SingleProc6.EnergyCurrentState="Standby")and (Buffer2.Empty or
937
and
938
and
939
SingleProc1.cont.remainingProcTime))) and (SingleProc6.EnergyCurrentState="Standby")and
940
and
and
941
Buffer1.cont.name="Entity5") or Buffer1.Empty ) and
942
and
943
and
944
and
and
945
and
and
946
(SingleProc6.EnergyCurrentState="Standby" ) and ((Buffer2.cont.name="Entity3" or
(SingleProc6.EnergyCurrentState="Standby" ) and ((Buffer2.cont.name="Entity3" or
947
948
Buffer1.Empty or (Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity5")) then
949
950
951
952
953
+SingleProc4.ProcTime)and (SingleProc6.EnergyCurrentState="Standby") and
((SingleProc1.cont.remainingProcTime+SingleProc1.ProcTime-SingleProc5.ProcTime)>TT) and (
SingleProc4.Empty or ((SingleProc4.EnergyCurrentState="Working" and
954
(SingleProc3.cont.remainingProcTime<= SingleProc4.cont.remainingProcTime)) and
955
956
957
SingleProc5.ProcTime)>TT) and (((SingleProc2.EnergyCurrentState="Working") and
and ((Buffer2.cont.name="Entity2" or Buffer2.cont.name="Entity6")or (Buffer2.cont.name="Entity1"
or Buffer2.cont.name="Entity4") or Buffer2.Empty) and Buffer3.Empty and
elseif (SingleProc3.EnergyCurrentState="Working" and
(((SingleProc2.EnergyCurrentState="Working") and ((SingleProc2.cont.name="Entity1" or
958
959
960
961
962
963
emainingProcTime> SingleProc3.cont.remainingProcTime)and
964
Buffer1.Empty) then
Buffer1.Empty) then
965
Buffer1.Empty) then
966
me+SingleProc2.ProcTime))and (SingleProc6.EnergyCurrentState="Standby") and (Buffer2.Empty
967
Buffer1.Empty) then
968
Buffer1.Empty) then
969
Buffer1.Empty) then
970
971
972
ime+SingleProc2.ProcTime))and (SingleProc6.EnergyCurrentState="Standby")and (Buffer2.Empty or
me+SingleProc2.ProcTime))and (SingleProc6.EnergyCurrentState="Standby")and
973
SingleProc5.ProcTime)>TT) and (SingleProc6.EnergyCurrentState="Standby") and
974
975
976
977
978
979
980
981
982
983
Buffer1.Empty) then
984
Buffer1.Empty) then
985
or Buffer2.cont.name="Entity5")) and Buffer3.Empty and ( Buffer1.Empty or
Buffer1.Empty) then
986
987
988
989
990
ocTime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Operational" or
cTime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Operational" or
ocTime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and
991
cTime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and
ocTime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Operational" or
Buffer1.Empty) then
992
cTime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Operational" or
Buffer1.Empty) then
ocTime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and
cTime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and
993
ime+SingleProc1.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and (Buffer2.Empty
994
me+SingleProc1.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and
and ((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-SingleProc5.ProcTime)>TT)and
Buffer1.Empty) then
me+SingleProc1.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and
995
and((SingleProc4.cont.remainingProcTime+SingleProc4.ProcTime-SingleProc5.ProcTime)>TT)
996
997
and Buffer3.Empty and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity6") ) then
998
and Buffer3.Empty and ((Buffer1.cont.name="Entity2" or Buffer1.cont.name="Entity6") ) then
999
SingleProc5.ProcTime)>TT)and (SingleProc6.EnergyCurrentState="Standby") and (Buffer2.Empty
SingleProc5.ProcTime)>TT)and (SingleProc6.EnergyCurrentState="Standby") and
1000
SingleProc3.cont.remainingProcTime) and(SingleProc6.EnergyCurrentState="Standby") and
(SingleProc3.cont.remainingProcTime+ SingleProc3.ProcTime))
me+ SingleProc3.ProcTime)) and(SingleProc6.EnergyCurrentState="Operational" or
1001
me+ SingleProc3.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and
1002
1003
1004
Buffer1.Empty) then
Buffer1.cont.name="Entity4")or (Buffer1.cont.name="Entity3" or Buffer1.cont.name="Entity5"))
1005
1006
1007
1008
1009
1010
1011
and(SingleProc6.EnergyCurrentState="Standby") and ( Buffer2.Empty or
1012
Buffer1.Empty) then
1013
ime+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and (Buffer2.Empty
1014
me+SingleProc2.ProcTime)) and (SingleProc6.EnergyCurrentState="Standby") and (Buffer2.Empty
elseif (SinglePro

Manzone Nervi Thesis

Загружено:

Сведения о документе

Исходное описание:

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Manzone Nervi Thesis

Загружено:

Авторское право:

Доступные форматы

Corso di Laurea in Ingegneria Gestionale

Energy Efficient Policies for a

Co-supervisor: Ing. Claudio Palasciano

Valeria Manzone 819332

Cecilia Nervi 818649

Academic Year 2015-2016

ABSTRACT .................................................................................................................................. XIII

EXECUTIVE SUMMARY ........................................................................................................... XV

EXECUTIVE SUMMARY ..................................................................................................... XXXV

2. STATE OF ART OF ENERGY EFFICIENCY PRODUCTION PLANNING AND

3. RESEARCH FRAMEWORK ................................................................................................ 32

4 MODEL DEVELOPMENT .................................................................................................... 39

5. SIMULATION FRAMEWORK ............................................................................................ 91

6. EXPERIMENTS AND RESULTS ANALYSIS .................................................................. 102

7. CONCLUSIONS AND FURTHER DEVELOPMENTS ............................................... 137

Bibliography ................................................................................................................................... 140

ANNEXES ...................................................................................................................................... 145

Annex 1: Experiments ................................................................................................................... 145

Annex 2: Code ................................................................................................................................ 172

Equation 1: Energy efficiency formula [7]

II. Thesis Aim and Structure

III. Literature Analysis Results

IV. Research Design

V. Conceptual Models Creation and Models Deployment

• Working: in this state the machine is working a job;

In our work the machines are considered in working or idle state.

-­‐ routing phase;

Figure 6-2: Representation of the Manzone Nervi 1 policy

Figure 6-4: Representation of the Manzone Nervi 2 policy

VI. Experiments and Results Analysis

Decision Controllable Non controllable Performance

Inter arrival time

Stage 1 Stage 2 Stage 3

00:00:30 00:00:00 00:01:30 00:01:30 00:01:30

00:01:00 00:00:30 00:00:30 00:01:30 00:02:30

00:01:30 00:01:00 00:00:30 00:01:30 00:04:30

00:02:00 00:01:30 00:01:40 00:02:20 00:03:10

Table 12: Design of experiments

Figure 6-12: IAT variation effect: ProcTime=(00:00:30-0:01:30-00:04:30); TT= 00:00:30

- percentage decrease of energy saving compared to the base case;

- the energy-saving policies;

- the information update in real time through ICT infrastructures.

Equazione 1: Formula efficienza energetica [7]

II. Scopo e Struttura della Tesi

Le politiche energetiche esistenti non prendono in considerazione l’infrastruttura ICT che

L’obiettivo che vogliamo perseguire è duplice, innanzitutto aumentare l’energy efficiency in un

V. Creazione dei Modelli Concettuali e loro Implementazione

-­‐ Working: in questo stato la macchina sta lavorando un job;

- fase decisionale sullo stato energetico delle macchine.

Figura 6-2: Rappresentazione grafica Manzone Nervi 1

Figura 6-4: Rappresentazione grafica Manzone Nervi 2

VI. Esperimenti ed Analisi dei Risultati

Variabili Fattori Fattori non Variabili di

Capacità dei buffer X

Per quanto riguarda le variabili in output consideriamo il consumo energetico e il makespan

Reparto A Reparto B Reparto C

00:00:30 00:00:00 00:01:30 00:01:30 00:01:30

00:01:00 00:00:30 00:00:30 00:01:30 00:02:30

00:01:30 00:01:00 00:00:30 00:01:30 00:04:30

00:02:00 00:01:30 00:01:40 00:02:20 00:03:10

Tabella 12: Design degli esperimenti

- diminuzione percentuale del risparmio energetico rispetto al caso base;

esiste un TT per cui la politica non ha più effetto? Se si, qual è?

-‐ routing phase;

-‐ Working: in questo stato la macchina sta lavorando un job;

- Check: measurement of critical performances after the carried out interventions;  

Figure 1–5: Deming cycle [1]  

The machines should be put in standby mode if: 

-‐ Working: in this state the machine is working a job;

-‐ the job j arrives in the current buffer;

-‐ i: machines i=1…M;

-‐ i: machines i=1…M;

-‐ t* → arrival time of “current job” at the machine

-‐ tidle → time spent by the machine in idle energy state;