Emulation Modules¶

Emulation modules are classified in three categories:

Actuators (i.e. controlable physical transformation of products and resources)
(uncontrolable) Physical processes (products holder, failures, etc...)
Observers

Actuators¶

Create¶

The create actuator (seme.emulation.CreateAct) creates new products and put them into a holder. When emulation begins, the create actuator wait for requests to arrive on its request_socket. When a request arrives, it verify that the requested action is ‘create’, and create a new product. If the request’s date is in the future, the actuator waits until the emulation time is greater or equal than the request date (NB: the request in the module’s request socket must be sorted in chronological order). The product creation is done accroding to the parameter ‘productType’ and ‘pid’ of the request. Default value are used if the parameters are missing. The newly ccreated product is finally put into the ‘destination’ Holder, and a report (‘create-done’) is sent in the module’s report socket.

Properties:

destination

the Holder where to put the created product

product_prop

a list of physical properties that the created product will have

Action keywords (what):

create

request the creation of a product

create-done

report the creation of a product

Action parameters (how):

PID

the identifiant of the new product(by default, the smaller free PID is chosen).

productType

the type of product to create (by default, ‘defaultType’).

physical-properties

a dictionary of physical properties to initialize for the created product.

Instanciation of a create actuator:
model = emulation.Model()
h = emulation.Holder(model, "holder1")
c = emulation.CreateAct(model, "create1", h)
Simple control of a create actuator:
class ControlCreate(emulation.Process):
    """Simple Simpy Process to control the create actuator"""
    def run(self, modules):
        """Process execution method"""
        createModule = modules["create1"]
        m = emulation.Request("create1", "create")
        yield emulation.put, self, createModule.request_socket, [m]
Control of a create actuator, using creation date and physical properties:
class ControlCreate(Process):
    """Simpy Process to control the create actuator"""
    def run(self, model):
        """Process execution method"""
        createModule = model.modules["create"]
        request_list = []
        r = Request("create", "create", date=2
                    params={'productType':"P_heavy",
                            'physical-properties': {'mass':12, 'length': 5}}))
        request_list.append(r)
        r = Request("create", "create", date=10
                    params={'productType':"P_light",
                            'physical-properties': {'mass':2, 'length': 5}}))
        request_list.append(r)
        r = Request("create", "create", date=10
                    params={'productType':"P_small",
                            'physical-properties': {'mass':2, 'length': 0.1}}))
        request_list.append(r)
        yield put, self, createModule.request_socket, request_list

Dispose¶

The dispose actuator (seme.emulation.DisposeAct) disposes the first product of a holder. When emulation begins, the dispose actuator waits for requests to arrive on its request socket. When a request arrives, it verify that the requested action is ‘dispose’, fetch a product from the ‘source’ holder, and mark it as disposed (by calling the product’s dispose() method). If the request’s date is in the future, the actuator waits until the emulation time is greater or equal than the request date (NB: the request in the module’s request socket must be sorted in chronological order). Finally, a report (‘dispose-done’) is sent in the module’s report socket.

Properties:

source

the holder where to take the product to dispose.

Action keywords (what):

dispose

request to dispose a product.

dispose-done

report that a product has been disposed

Instanciation of a Dispose actuator:
model = emulation.Model()
h = emulation.Holder(model, "holder1")
d = emulation.DisposeAct(model, "dispose1", h)

Shape¶

A Shape Actuator (seme.emulation.ShapeAct) changes a set of physical attributes of a product. A Shape actuator is associated with a Holder (its transformation holder), where products reside during their transformation (NB: a Shape Actuator cannot load/ unload product to/from its transformation holder, a Space actuator is required to do that).

Properties:

program_table

A dictionary of available programs (i.e. program that can be run by this actuator). |

setup

A SetupMatrix instance, that is used to compute setup delays.

holder

The Holder where the transformation is done. |

Program parameters:

change

A dictionary of physical properties affectation. Keys are physical properties names, values are affectation to this properties.

Action keywords (what):

setup

request a program change.

make

request execution of the current program.

setup-done

report that a setup has been done.

busy

report that the actuator is now busy.

idle

report that the actuator is now idle.

Action parameters (how):

program

The name of the program to set up (when associated with the ‘setup’ action). If the action is ‘make’, an implicit setup is done if nessecary (i.e. if the current program is not the requested program).

Instanciation and initialization of a Shape actuator:
model = Model()
espaceMachine = Holder(model, "espaceMachine")
machine = ShapeAct(model, "machine", espaceMachine)
machine['program_table']['p1'] = Program(None, 4)
machine['program_table']['p2'] = Program(None, 5)
machine['program_table']['p3'] = Program(None, 6)
m = SetupMatrix(1)
m.add('p1','p3',2)
m.add('p3','p1',3)
machine['setup'] = m

Space¶

A Space actuator (seme.emulation.SpaceAct) change the position of a product. The move is done according to the keys ‘source’ and ‘destination’ of the programs, that point to Holders. During its production cycle, this actuator fetch the first product of the ‘source’ holder, and after the program delay, put it in the destination Holder. The position change is recorded by the product, as well as being in the Space actuator.

Properties:

program_table

A dictionary of available programs (i.e. program that can be run by this actuator).

setup

A SetupMatrix instance, that is used to compute setup delays.

Program parameters:

source

A holder from where the products are taken.

destination

A holder to where the product are put.

Action keywords (what):

setup

Request a program change.

move

Request execution of the current program.

setup-done

Report that a setup has been done.

busy

Report that the actuator is now busy.

idle

Report that the actuator is now idle.

Action parameters (how):

program

The name of the program to set up (when associated with the ‘setup’ action). If the action is ‘make’, an implicit setup is done if nessecary (i.e. if the current program is not the requested program).

Instanciation of a Space actuator:
model = Model()
source = Holder(model, "source")
sink = Holder(model, "sink")
espaceMachine = Holder(model, "espaceMachine")

sp = SpaceAct(model, "transporter")
sp['program_table']['load'] = Program({'source':source,
                                       'destination':espaceMachine}, 2)
sp['program_table']['unload'] = Program({'source':espaceMachine,
                                         'destination':sink}, 2)

Assemble¶

An assemble actuator assemble a product taken from a ‘source’ holder, with the product currently present in an assembly holder. The incoming product is added as a component of the product that is in the assembly holder. Note that this actuator cannot load or unload the product in the assembly holder: it must be explicitly moved or created into the holder, and moved from the holder after transformation.

Properties:

program_table

A dictionary of available programs (i.e. program that can be run by this actuator).

setup

A SetupMatrix instance, that is used to compute setup delays.

holder

The holder in which the assembly is made.

Program parameters:

source

A holder from where the product are taken.

Action keywords (what):

setup

Request a program change.

assemble

Request execution of the current program.

setup-done

Report that a setup has been done.

busy

Report that the actuator is now busy.

idle

Report that the actuator is now idle.

Action parameters (how):

program

The name of the program to set up (when associated with the ‘setup’ action). If the action is ‘make’, an implicit setup is done if nessecary (i.e. if the current program is not the requested program).

Instanciation of a Assemble actuator:
model = emulation.Model()
source1 = emulation.Holder(model, "source1")
source2 = emulation.Holder(model, "source2")
assy_space = emulation.Holder(model, "assy_space")
assy = emulation.AssembleAct(model, "assy", assy_holder = assy_space)
assy['program_table']['p1'] = emulation.Program({'source':source2}, 5)
assy['program_table']['p2'] = emulation.Program({'source':source1}, 3)

Disassemble¶

A disassemble actuator take a product, and decompose it into two products: one that stay in the disassembly holder, while the other one is put the ‘destination’ holder.

Properties:

program_table

A dictionary of available programs (i.e. program that can be run by this actuator).

setup

A SetupMatrix instance, that is used to compute setup delays.

holder

The holder in which the disassembly is made.

Program parameters:

destination

A holder from where the disassembled products are put.

Action keywords (what):

setup

request a program change.

disassemble

request execution of the current program.

setup-done

report that a setup has been done.

busy

report that the actuator is now busy.

idle

report that the actuator is now idle.

Action parameters (how):

program

The name of the program to set up (when associated with the ‘setup’ action). If the action is ‘make’, an implicit setup is done if nessecary (i.e. if the current program is not the requested program).

Instanciation of a Disassemble actuator

Physical Processes¶

Failure¶

A failure is an event that happen after mtbf units of time, and that modify the performance of one or sevaral actuators during mttr units of times. Then the failure can be repeated. The mtbf and mttr parameters can be strings that uses the ‘rng’ token, as an instance of the model’s random number generator. For instance ‘rng.expovariate(1/20)’ is a valid expression, that is evaluated each time the failure enters the ‘wait mtbf’ state.

There are two type of failures: complete or partial (performance degradation)

If the failure is complete, the resource supporting the actuation process is preempted, and released after mttr. The operation interrupted is resumed. For example, if a complete failure of duration 5 happen at t=2, while the actuator is processing a task of lenght 10 that have begun at t=0, the actuator is reported failed from t=2 to t=7, and then resume its processing from t=7 to t=15 (8 time unit remain)

If the failure is partial, a capacity modification is applied during a period that correspond to the mttr. The capacity modification is a positive number usualy comprised between 0 and 1, that is substracted to the resource capactity. For exemple, if applying a capacity degradation of 0.3 (30%) on an initial capacity of 1, results in a capacity of 0.7. When the capacity is degraded, the actuator is interrupted; the remaining time is evaluated (on the basis of a normal (i.e. 100%) capacity), and the waiting_time is avaluated according to the new capacity: new_time = remaining_time / new_capacity When the capcity is restored, a similar operation is done.

Properties:

mtbf

the expression the give the mean time before failure

mttr

the expression the give the mean time to repair

degradation

the degradation ratio (between 0 and 1) (optional, default value is 1)

repeat

True is the failure repeats

Action keywords (what):

failure-begin

report that the failure begin

failure-end

report that the failure process ends

Action parameters (how):

mttr

the actual value of the failure

degradation

the degradation of the failure (1 if the failure is total)

Holder¶

a Holder contains products. It is associated with a place where products can be, for instance an inventory or the iner space of a machine of station. A Holder can contains several products, and behave like a simple FIFO queue. Space and create actuators can put product into an holder. The new product is added at the end of the queue. Space and dispose actuators can take a product from a holder, the taken product is the one in the front of the queue.

Properties:

capacity

The maximum number of product that can be put in a holder. A null value means an infinite capacity.

speed

The speed determine how uch time a product takes to change position inside the holder. For instance, it take 4 units of time to go through a holder with capacity 2 and speed 0.5. A null value means an infinite speed.

Instanciation of a Holder:
h = emulation.Holder(model, "holder1")
h['capacity'] = 4
h['speed'] = 1

Observers¶

PushObserver¶

A Push Observer returns information on product. When a product is ready in the observed holder (i.e. the first product of the holder can be get), the module send a Report. The report attributes depends of the module properties. The reports are pushed into the control system.

Properties:

holder

The holder where the products to observe are.

event_name

The name of the event that is generated when a product is observed.

observe_type

Observe product type. If true, the observer report the type of the observed product.

identify

Identify products. If true, the observer report the pid of the observed product.

Report parameters (how)

productType

The type of the observed product. Used only if property observe_type is True.

productID

The PID of the obersed product. Used only if property identify is True.

Instanciation of a PushObserver:
obs1 = emulation.PushObserver(model, "observer1", "ev1", observe_type = False, holder = h)

Emulation Modules¶

Actuators¶

Create¶

Dispose¶

Shape¶

Space¶

Assemble¶

Disassemble¶

Physical Processes¶

Failure¶

Holder¶

Observers¶

PushObserver¶

PullObserver¶

Table Of Contents

Previous topic

Next topic

This Page

Navigation

Emulation Modules¶

Actuators¶

Create¶

Dispose¶

Shape¶

Space¶

Assemble¶

Disassemble¶

Physical Processes¶

Failure¶

Holder¶

Observers¶

PushObserver¶

PullObserver¶

Table Of Contents

Previous topic

Next topic

This Page

Quick search

Navigation