Manufacturing SM Simplified

Manufacturing M&S Project, Simplified
Problem Description
Problem Statement
In a manufacturing plant, management is interested in automating the loading/unloading of components
into/from three machines as well as the movement of components between the machines with power
roller conveyors. Two conveyors unload components from the first machine, one for each of 2 types of
component, and move the components for loading into two other machines (that each process one of the
component types). The length of these conveyors is limited and can lead to downtime in the first
machine when one of the conveyors becomes full.
Since lengthening the conveyors increases cost, management wishes to keep the lengths as short as
possible but maintain minimal downtime of the first machine.
SUI Details
A department in a manufacturing plant processes two streams of partially completed components (A and
B) using three different machines. The plant operates 24 hrs/day, 7days/week.
Plant Components and Resources
Components: The manufacturing plant process to types of components: A and B.
Machines: Three machines are used to process the components. Machine M1 processes both types of
components, while machine M2 processes only type A components and machine M3 processes only
type B components. Figure 1 shows the layout of the three machines used to process the components.
M2
M2
M1
M1
B
A
A
M3
M3
B
Figure 1 Current Layout of the Plant
Conveyors: Power roller conveyors are being added to automate the loading/unloading of components
and moving components to and from the machines to improve throughput. Figure 2 shows the layout of
the plant with conveyors.
M2
M2
A
M1
M1
A
A
B
A
B
M3
M3
B
B
Figure 2 Layout of the Plant with Power Roller Conveyors
Employees: Three employees are responsible for moving and loading components into the machines.
Processing Components
The components are first processed at machine M1 and upon completion each type of component flows
into two separate paths so that A components are processed at machine M2 and B components are
processed at machine M3.
Current Operation: Moving components, loading components into machines and unloading
components out of the machines is done manually and currently the responsibility of 3 employees.
1) One employee is responsible for moving arriving components into machine M1. When the
machine M1 has completed its operation the employee replaces the component with another (if
available) and the moves the component to machine M2 or M3 according to its type.
2) A second employee is responsible for Machine M2. When a type A component is available, the
employee loads machine M2 with the component and removes it when the machine has
completed its processing and places it in pickup area.
3) A second employee is responsible for Machine M3. When a type B component is available, the
employee loads machine M3 with the component and removes it when the machine has
completed its processing and places it in pickup area.
Operation with Conveyors: Conveyors for augmenting throughout will move components between
machines and load/unload components to/from machines automatically. The role of employees are to
load components onto the conveyor that brings components to machine M1 and remove components
from the conveyors that unloads components from machines M2 and M3. Thus one employee is
dedicated to load the conveyor leading to machine M1, while the other two employees unload the
conveyors moving components away from machines M2 and M3.
The conveyors between machine M1 and machines M2 and M3 are of limited length. When one of
these conveyors is full, a component in machine M1 destined for that conveyor will remain in the
machine after processing until space becomes available in on the conveyor. This prevents further
processing in machine M1 and slows down component processing.
Project Goal
The goal of the simulation project is to determine the length of the conveyors between machine M1 and
the two machines M2 and M3 that minimizes the downtime for machine M1.
Parameters
Q.Conveyors[M2].length: The maximum number of components the conveyor leading to

machine 2 can hold (3 to 10).
Q.Conveyors[M3].length: The maximum number of components the conveyor leading to
machine 3 can hold (3 to 10).
Experimentation
Study: Steady state study.
Observation Interval:
Time units are minutes
Cannot be predetermined because a steady state study is required
Experimentation: The length of each conveyor leading to machines M2 and M3 is initially set to 3
components and can be lengthened to accommodate up to 10 components. The length of each conveyor
is increased using the following strategy.
Initially set the length of the conveyors to 3 components and use experimentation to determine
the percentage of time each conveyor is full and machine M1 is down.
The length of the conveyor with the largest percentage of time full in increased to accommodate
one more component and a new experiment undertaken.
Experiments are repeated until the downtime of M1 less than 10%.
Output
percentTimeC2Full, percentTimeC3Full: Percentage of time conveyor between M1 and M2

(Q.Conveyors[M2]) is full, and percentage of time the conveyor between M1 and M3
(Q.Conveyors[M3]) is full, respectively. This output is used to increase the length of each
conveyor between experiments and facilitates experimentation.
percentTimeDown : Percent of time M1 is down: Downtime is measured as the percentage of
time M1 contains a component and is not working (the component cannot be moved out of the
machine). Note that the machine with no component and not working is not considered to be
down.
ABCmod Conceptual Model

High Level Conceptual Model
Simplifications
Employees are not modelled given that the focus on the study in on the length of the conveyors
between machine M1 and the other 2 machines.
The conveyor that brings components to machine M1 can be modelled as having an unlimited
length, given that an employee will feed any arriving components when space becomes free on
the conveyor.
Conveyors that remove components from machines M2 and M3 are not modelled. Given that
employees are constantly removing components from these conveyors, it is not expected that the
conveyors can become full. Thus when either machine finishes with a component, the
component is assumed to leave the SUI.
The time for conveyors to move components to the machines are considered negligible.
Structural View
R.Machines
[M2]
Q.Conveyors[M1]
R.Machines
[M1]
Q.Conveyors[M2]
Q.Conveyors[M3]
R.Machines
[M3]
Legend
iC.Component
Figure 1 Manufacturing Structural Diagram

Entity Structures
1. iC.Component: represents the components processed by the department. The attribute type identifies
the component type (has a value of A or B).
2. R.Machines: The set of machines that process the components. The symbols M1, M2 and M3 are
the identifiers of each member of the set. Thus the identifiers of the entities representing the
machines are:
a. Machine M1: R.Machines[M1]
b. Machine M2: R.Machines[M2]
c. Machine M3: R.Machines[M3]
3. Q.Conveyors: The set of queues represent the three conveyors that feed each of the machines. The
symbols M1, M2, and M3 are also used to identify the members of the set. The queue
Q.Conveyors[M1] represents the conveyor leading to machine M1 and has an unlimited length, since
an employee continuously feeds the conveyor when any components are available and space is
available on the conveyor (in fact the queue represents the conveyor and all components in the
department ready for processing by machine M1). The other two conveyors, Q.Conveyors[M2] and
Q.Conveyors[M3], represent the conveyors that move components from R.Machines[M1] to
R.Machines[M2] and R.Machines[M3] respectively. The lengths of these queues are limited and
defined by parameters Q.Conveyors[M2].length and Q.Conveyors[M3].length.
Behavioural View
CompArrivals
CompProcessing
MoveCOutOfM1
CompProcessing
(Processing in
R.Machines[M1],
component left in
machine)
(Moves component onto

Q.Conveyors[M2] or
Q.Conveyors[M3]
CompProcessing
(Component processing
in R.Machines[M2] or
R.Machines[M3])
MoveCOutOfM1
Component Lifecycle
Machine M1 Lifecycle
Figure 2 Manufacturing Behavioural Diagram

Scheduled Action Constructs:
CompArrivals: Arrivals of components to the department.
Conditional Action Constructs:
MoveCOutOfM1: This conditional action moves a component out of machine M1 when space
is free in one of the conveyors M2 (if component in the machine is of type A) or M3 (if
component in the machine is of type B). The use of the conditional action are required since it is
possible that at the end of this activity, the component will remain in R.Machine[M1] because
the destination conveyor (queue) is full. Machine M2 only processes A components while
machine M3 processes only B components.
Activity Constructs:
CompProcessing: Processing of components at any of the three machines. In the case of
processing the component in machine M1, this activity does not move the components out of the
machine. The conditional action performs this action when space is available on the appropriate
conveyors. For machines M2 and M3, the component leaves the system once processing is
completed (shown in the component life cycle diagram)
Input
Variable
uCArr
Variable
iC.Component.uType
uProcTimeM1
uProcTime
Exogenous Input (Entity Streams)

Description
Domain
Sequence
Range Sequence
Input entity stream variable of

components.
N/A 1 component
arrives at each
arrival time.
RVP.DuArr()
Endogenous Input (Entity Streams)

Description
Values
The type of component that is
set upon arrival of the
component.
Processing times for machine
M1. Dependent on the
machine type, A or B.
Processing times in machine
M2 and M3. The time is
dependent on the machine.
RVP.uCompType()
RVP.uProcTimeM1(type)
RVP.uProcTime(machine)
Detailed Conceptual Model

Structural Components
Constants
Description
Name
M1, M2, M3
Identifier for set categories R.Machines and

Q.Conveyors. The identifiers serve to
associate each Q.Conveyors entity to a
R.Machines entity/
Value
0, 1, 2
Parameters
Description
Name
Q.Conveyors[M2].length
Q.Conveyors[M3].length
The maximum number of components that

the Q.Conveyor[M2] can hold.
The maximum number of components that
the Q.Conveyor[M3] can hold.
Value
3 to 10
3 to 10.
Consumer Class: Component

Components processed by the department.
Attributes
Description
uType
Set to A or B to reflect the type of component.
Resource Set[3]: Machines

The 3 machines in the system. M1, M2 and M3 are the three identifiers of the machines.
Attributes
Description
busy
Set to TRUE when the machine is processing a component and FALSE

otherwise.
References a component entity being processed. Set to NOCOMP to indicate
component is not present in the machine (for machine M1).
component
Queue Set[3]: Conveyors

The three conveyors in the model. M1, M2 and M3 are the three identifiers of the conveyors.
Attributes
Description
n
list
length
The number of components on the conveyor.

The list of component entities on the conveyor.
The length of the conveyor. The attribute is used for R.Conveyors[M2] and
R.Conveyors[M3]. The R.Conveyors[M1] is assumed to have an infinite
length.
Behavioural components
Time units: minutes
Observation interval: Steady state study determined during experimentation.
Action: Initialise
TimeSequence
Event SCS
<0>
FOR ix in M1 to M3
R.Machines[ix].busy FALSE
R.Machines[ix].component NOCOMP
Q.Conveyors[ix].N 0
ENDFOR
(the length attributes are assumed to be set)
Output
OUTPUTS
Trajectory Sequences
Description
Name
TRJ[m1Down]
TRJ[timeConv2Full]
TRJ[timeConv3Full]
Trajectory sequence reflects the time that machine M1 is down. The output variable m1Down
is 1 when R.Machines[M1].busy is FALSE and R.Machines[M1].component is not NOCOMP
and 0 otherwise.
Reflects the time that Q.Conveyors[M2] is full, that is, the output variable timConv2Full is 1
when Q.Conveyors[M2].n = Q.Conveyors[M2].length and 0 otherwise.
Reflects the time that Q.Conveyors[M3] is full, that is, the output variable timConv3Full is 1
when Q.Conveyors[M3].n = Q.Conveyors[M3].length and 0 otherwise.
Derived Scalar Output Variables (DSOV's)

Description
Data Sequence
Name
Name
percentTimeDown
percentTimeC2Full
percentTimeC3Full
Percentage of time the machine M1 is down.

Percentage of time the conveyor leading to
machine M2 is full.
Percentage of time the conveyor leading to
machine M3 is full.
Operator
TRJ[m1Down]
TRJ[timeConv2Full]
Average
Average
TRJ[timeConv3Full]
Average
User Defined Procedures

Name
ConveyorReadyForComp()
MachineReadyForProcessing()
User-Defined Procedures
Description
Returns the identifier of the Q.Conveyors set into which the component from
R.Machine[M1] can be moved into. The following conditions must be met to move a
component:
1) R.Machines[M1].busy is FALSE
2) R.Machines[M1].component must reference an iC.Component entity (i.e. not
NOCOMP).
3) Space is available for on the conveyor for the component, either:
a. R.Machines[M1].component.uType = A (i.e. an A component is in the machine)
and Q.Conveyors[M2].n is less than Q.Conveyors[M2].length OR
b. R.Machines[M1].component.uType = B (i.e. a B component is in the machine)
and Q.Conveyors[M3].n is less than Q.Conveyors[M3].length
If 3a is true, return M2, if 3b is true, return M3, otherwise return NONE (no component
can be moved).
Returns the identifier, id, of a member of the R.Machines category under the following
conditions:
1) R.Machines[id].busy is false
2) R.Machines[id].component is equal to NOCOMP
3) Q.Conveyors[id].n is non-zero
If no machine is ready for component processing, NONE is returned.
Input Constructs
Random Variate Procedures
Description
Name
DuCArr()
uCompType()
uProcTime(machineId, type)
Data Model
Returns the next arrival time for a

t + Exponential(MEAN_INTER_ARR)
component. Assumes that an arrival where
has occurred at current time t.
MEAN_INTER_ARR = 7.0 minutes
Returns the a component type A or
Returns A, PERCENT_A of the time
B.
Returns B, PERCENT_B of the time
Where PERCENT_A = 0.55, PERCENT_B = 0.45
Provides the processing times for
machineId is M1 and
machines M1, M2 and M3; machine
type is A: Exponential(MEAN_PROC_TIME_M1_A)
has one of the id values M1, M2, or
type is B: Exponential(MEAN_PROC_TIME_M1_B)
M3. The processing time for M1 is
where
dependent on the component type
MEAN_PROC_TIME_M1_A = 2.1 minutes
given by type (set to A or B)
MEAN_PROC_TIME_M1_B = 4.2 minutes
machineId is M2:
Exponential(MEAN_PROC_TIME_M2)
machineId is M3:
Exponential(MEAN_PROC_TIME_M3)
where
MEAN_PROC_TIME_M2 = 9.4 minutes
MEAN_PROC_TIME_M3 = 10.5 minutes
Action: CompArrivals
Arrival of A component.
TimeSequence RVP.DuCArr()
Event
iC.Component SP.Derive(Component)
iC.Component.type RVP.uCompType()
SP.InsertQue(Q.Conveyors[M1], iC.Component)
Behavioural Constructs
Activity: CompProcessing
Processing components at any of the machines. The UDP.MachineReadForProcessing() determines which
machine can start processing. Processing consists of removing a component from the Q.Conveyors[id] leading to
the machine, processing the component (duration determined by RVP.uProcTime(), and removing the component
from the machine. In the case of machines M2 and M3, the component leaves the system after processing. In the
case of machine M1, the component is left in the machine for removal by the conditional action.
Precondition UDP.MachineReadyForProcessing() NONE
Event
id UDP.MachineReadyForProcessing()
R.Machines[id].busy TRUE
R.Machines[id].component Q.RemoveQue(Q.Conveyors[id])
Duration
RVP.uProcTime(id, R.Machines[id].component.uType)
Event
R.Machines[id].busy FALSE
IF(id M1) THEN (Conditional action will remove component from machine M1)
R.Machines[id].component NOCOMP
SP.Leave(R.Machines[id].component)
ENDIF
Action: MoveCOutOfM1
Moving a component out of M1 when processing is complete and space is available on conveyor that
is to receive the component.
Precondition UDP.ConveyorReadyForComp() NONE
Event
qid UDP. ConveyorReadyForComp()
SP.InsertQue(Q.Conveyors[qid], R.Machines[M1].component)
R.Machines[M1].component NOCOMP
Design of Validation Experimentation

Given the simplicity of the model, it is possible to validate the model using a trace log as described
below. The model shall be validated for both the base case and the alternate case.
Trace Logging
The state of the simulation model is monitored by tracking the number of customers in Q.CustLine, the
number of customers in RG.Counter, and the input variable RG.Counter.uNumEmp. These values are
presented on a single line as follows:
Clock: xxxxxxx
M1:
QConveyors[].n: xx
M2:
QConveyors[].n: xx
M3:
QConveyors[].n: xx
R.Machines[].busy: xx
R.Machines[].component: xx
where the xxxs are replaced with the current value of the clock and designated attribute values. In the
case of R.Machines[M1] component, the value will be set to either A, B, or NO_COMP.
Simulation Model
Design of Simulation Model and Program
The simulation model is implemented in the class Manufacturing (an extension of the ABSmod/J class
AOSimulation model) and a number of other classes used to implement the various constructs from the
ABCmod conceptual model. All Java classes that make up the Java Kojo Kitchen simulation model are
placed in the Java package manufacturing.
The following table shows how the various ABCmod entity structures are mapped to Java classes and
how objects instantiated from these classes are reference by the Manufacturing class.
Entity Structures
Java Class
ABCmod
Construct
iC.Component Component
Notes: The enumerated data type CompType is
defined to restrict the values of the uType
attribute to A and B.
Machines
R.Machines
The constant NO_COMP is defined in this class
as the value for the component to indicate
no component.
Q.Conveyors
Object References
Typically by the reference
variable icComponent in the
various methods that
manipulate Component objects.
Manufacturing.rMachines
The above reference variable

references an array of 3
Machines objects.
Conveyors
Manufacturing.qConveyors
The queue is implemented using the

ArrayList (standard Java Class), referenced
The above reference variable
references an array of 3
by the private reference variable conveyor
Notes
Conveyors objects.
Methods in the class are implemented to
provide values for the attribute n
(obtained using conveyor.size()),
implement the InsertQue and RemoveQue
standard procedures (as spInsertQue and
spRemoveQue methods.
The following table provides mapping between the conceptual model Action/Activities to Java classes.
Actions/Activities
ABCmod Constructs
Java Classes
CompArrivals
CompArrivals
MoveCOutOfM1
MoveCOutOfM1
CompProcessing
CompProcessing
Other classes that make up the Kojos Kitchen ABSmod/J simulation model include:
Output (referenced by Manufacturing.output): Contains the Trajectory sets and methods for
computing the DSOVs.
RVPs (referenced by Manufacturing.rvp): Contains the Java methods used to implement the CM
RVPs.
Seeds: The class used to pass seeds for random number generators used in implementing the
various RVPs.
The package manufacturing provides public access to the following:
The constructor Manufacturing to allow creation and initialisation of a Manufacturing object,
The methods getPercentTimeDown (),getTimeC2Full(),getTimeC3Full() to allow access the
value of the output variables percentTimeDown, percentTimeC2Full, and percentC3Full
respectively.
All public methods provided by the class AOSimulation (e.g. runsimulation) for supporting
experimentation.
Results of the Validation Experimentation

Beginning of the observation interval
onveyor Limits: 3, 3
Run, AverageM1Down, AverageConvM2Full, AveragemConvM3Full
Clock =
0.0000
M1: qConveyor[].n= 0, R.Machines[].busy=false, R.Machines[].component=NO_COMP
M2: qConveyor[].n= 0, R.Machines[].busy=false
------------SBL---------TimeStamp:1.6513649274127358 Activity/Action: manufacturing.CompArrivals
TimeStamp:1440.0 Stop Notification
--------------------->-----------------------------------------------<
Clock =
1.6514
M1: qConveyor[].n= 0, R.Machines[].busy=true, R.Machines[].component=A
------------SBL---------TimeStamp:1.6953603579942156 Activity/Action: manufacturing.CompProcessing (M1)
TimeStamp:4.573897233813957 Activity/Action: manufacturing.CompArrivals
--------------------->-----------------------------------------------<
Clock =
1.6954
M2: qConveyor[].n= 0, R.Machines[].busy=true
--------------------->-----------------------------------------------<
Clock =
2.2050
When Conveyor is full

>-----------------------------------------------<
Clock =
24.2276
TimeStamp:48.64461538524931 Activity/Action: manufacturing.CompProcessing (M2)
--------------------->-----------------------------------------------<
Clock =
31.7095
M1: qConveyor[].n= 0, R.Machines[].busy=false, R.Machines[].component=A
--------------------->-----------------------------------------------<
Clock =
36.1119
--------------------->-----------------------------------------------<
Clock =
37.6706
--------------------->-----------------------------------------------<
Clock =
40.1620
--------------------->-----------------------------------------------<
Clock =
48.6446

----------------------
Annex A Data Modelling

Data collection and analysis has been completed for the project with the following results.
Interarrival times for components are exponentially distributed with the following means:
o A components: 12.7 minutes
o B components: 15.4 minutes
o These have been revised to provide interarrival times for all components and a data
model for the type of the arriving component below.
Processing times in each machine are also exponentially distributed with the following means:
o Machine M1, A component: 2.1 minutes
o Machine M1, B component: 4.2 minutes
o Machine M2: 9.4 minutes
o Machine M3: 10.5 minutes
Time for moving components on the conveyors take only a few seconds.
Data model for Interarrival Time of Components

Only a single input entity stream is to be modelled with a second data model for the data type. Thus the
interarrival times are modelled as exponentially distributed with a mean of 7.0 minutes.
Data model for Component Types
Distribution of types for arriving components are as follows: 55% Type A Components, 45 % Type B
components.

Manufacturing SM Simplified

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Manufacturing SM Simplified

Diunggah oleh

Hak Cipta:

Format Tersedia

Manufacturing M&S Project, Simplified

Figure 2 Layout of the Plant with Power Roller Conveyors

Q.Conveyors[M2].length: The maximum number of components the conveyor leading to

percentTimeC2Full, percentTimeC3Full: Percentage of time conveyor between M1 and M2

ABCmod Conceptual Model

Figure 1 Manufacturing Structural Diagram

(Moves component onto

Figure 2 Manufacturing Behavioural Diagram

Exogenous Input (Entity Streams)

Input entity stream variable of

Endogenous Input (Entity Streams)

Detailed Conceptual Model

Identifier for set categories R.Machines and

The maximum number of components that

Consumer Class: Component

Set to A or B to reflect the type of component.

Resource Set[3]: Machines

Set to TRUE when the machine is processing a component and FALSE

Queue Set[3]: Conveyors

The number of components on the conveyor.

Derived Scalar Output Variables (DSOV's)

Percentage of time the machine M1 is down.

User Defined Procedures

Returns the next arrival time for a

Design of Validation Experimentation

The above reference variable

The queue is implemented using the

The above reference variable

Results of the Validation Experimentation

When Conveyor is full

------------SBL---------TimeStamp:50.418289795559566 Activity/Action: manufacturing.CompProcessing (M2)

Annex A Data Modelling

Data model for Interarrival Time of Components

Anda mungkin juga menyukai