def simple_entity_graph():
"""Creates two Entities connected by one connector"""
source = merlin.Entity(name='source')
sink = merlin.Entity(name='sink')
in_con = merlin.InputConnector('unit_type', sink, name='input')
out_con = merlin.OutputConnector('unit_type', source, name='output')
in_con.source = out_con
out_con.add_input(in_con)
source.outputs.add(out_con)
sink.inputs.add(in_con)
return (source, sink, out_con, in_con)
def test_add_connection_event(self, sim):
source = merlin.Entity(simulation=sim, name='source', attributes=set())
sink = merlin.Entity(simulation=sim, name='sink', attributes=set())
sim.add_entity(source)
sim.add_entity(sink)
axs = merlin.Action.create(
"Entity {0} > Entity {1}, shoes, 1, True".format(
source.id, sink.id))
assert len(axs) == 1
a = axs[0]
a.execute(sim)
assert source.get_output_by_type('shoes')
assert sink.get_input_by_type('shoes')
def test_connect_entities(self, sim):
e1 = merlin.Entity(name='e1')
e2 = merlin.Entity(name='e2')
sim.add_entity(e1)
sim.add_entity(e2)
sim.connect_entities(e1, e2, 'unit_type')
o_con = e1.get_output_by_type('unit_type')
i_con = e2.get_input_by_type('unit_type')
assert e1.get_input_by_type('unit_type') is None
assert e2.get_output_by_type('unit_type') is None
assert o_con
assert i_con
assert o_con.type == 'unit_type'
assert i_con.type == 'unit_type'
assert len(o_con.get_endpoints()) == 1
assert i_con.source == o_con
def IPSbranch():
sim = merlin.Simulation()
# define outputs
pp_delivered = merlin.Output("count", name="passports printed")
sim.add_output(pp_delivered)
e_budget = merlin.Entity(name="budget", attributes={'budget'})
e_staff = merlin.Entity(name="staff", attributes={"resource"})
e_printer = merlin.Entity(name="printer", attributes={"asset"})
sim.add_entities([e_budget, e_staff, e_printer])
sim.set_source_entities([e_budget])
# connect all entities
sim.connect_entities(e_budget, e_staff, "$")
sim.connect_entities(e_budget, e_printer, "$")
sim.connect_entities(e_staff, e_printer, "FTE")
sim.connect_output(e_printer, pp_delivered)
# and finally add the processes to the entities
# so the processes are automatically hooked up to the
# entities connectors
e_budget.create_process(BudgetProcess, {
'name': "passportPrintingBudget",
'start_amount': 4000000,
})
e_staff.create_process(ppStaff, {})
e_staff.get_processes()[0].priority = 10
e_printer.create_process(ppPrinter, {})
# setup an apportioning bias for staff and printer budget
budget_out_con = e_budget.get_output_by_type("$")
budget_apportioning = {e_staff: 0.7, e_printer: 0.3}
new_biases = []
for ic, _ in budget_out_con.get_endpoints():
# if entity not in the apportioning, then just give no funds
new_biases.append((ic, budget_apportioning.get(ic.parent, 0.0)))
# set the end-point biases
budget_out_con.set_endpoint_biases(new_biases)
return sim
def test_connect_output(self, sim):
e1 = merlin.Entity(name='e1')
o = merlin.Output('unit_type', name='output')
sim.add_entity(e1)
sim.add_output(o)
sim.connect_output(e1, o)
o_con = e1.get_output_by_type('unit_type')
i_con = list(o.inputs)[0]
assert o_con
assert i_con
def test_parent_entity_action(self, computation_test_harness):
sim = computation_test_harness # type: merlin.Simulation
child_ent = merlin.Entity(name="child_ent")
parent_ent = sim.get_entity_by_name("Budget")
sim.add_entity(child_ent)
assert child_ent not in parent_ent.get_children()
assert child_ent.parent is None
a = merlin.ParentEntityAction(child_ent.id, parent_ent.id)
a.execute(sim)
assert child_ent in parent_ent.get_children()
assert child_ent.parent == parent_ent
def simple_branching_output_graph():
"""
Creates an entity with a single output that connects to two sink entities
"""
source = merlin.Entity(name='source')
sink1 = merlin.Entity(name='sink1')
sink2 = merlin.Entity(name='sink2')
in_con1 = merlin.InputConnector('unit_type', sink1, name='input')
in_con2 = merlin.InputConnector('unit_type', sink2, name='input')
out_con = merlin.OutputConnector('unit_type', source, name='output')
in_con1.source = out_con
in_con2.source = out_con
out_con.add_input(in_con1)
out_con.add_input(in_con2)
source.outputs.add(out_con)
sink1.inputs.add(in_con1)
sink2.inputs.add(in_con2)
return (source, sink1, sink2, out_con, in_con1, in_con2)
def OutputConnector_with_Endpoints():
outEntity = merlin.Entity()
# set no biases, rely on defaults
out = merlin.OutputConnector("$", outEntity, "testOut")
for i in range(4):
out.add_input(
merlin.InputConnector("$", outEntity, "testIn{:d}".format(i)))
return out
def computation_test_harness(sim) -> merlin.Simulation:
# Configure sim properties
sim.set_time_span(10)
sim.add_attributes(['budget', 'capability', 'fixed_asset'])
sim.add_unit_types(['$', 'desks', 'requests_handled'])
sim_output = merlin.Output('requests_handled', name='requests handled')
sim.outputs.add(sim_output)
# Create Entities
e_budget = merlin.Entity(name='Budget', attributes={'budget'})
e_call_center = merlin.Entity(name='call center',
attributes={'capability'})
e_office = merlin.Entity(name='office building',
attributes={'capability', 'fixed_asset'})
sim.add_entities([e_budget, e_call_center, e_office])
sim.set_source_entities([e_budget])
# Create Entity Connections
# Budget connections
sim.connect_entities(e_budget, e_call_center, '$')
sim.connect_entities(e_budget, e_office, '$')
# Call center connections
sim.connect_output(e_call_center, sim_output)
# Office connections
sim.connect_entities(e_office, e_call_center, 'desks')
# Add entity processes
e_budget.create_process(BudgetProcess, {'name': 'Budget'})
e_call_center.create_process(CallCenterStaffProcess,
{'name': 'Call Center Staff'})
e_office.create_process(BuildingMaintainenceProcess,
{'name': 'Building Maintenance'})
return sim
def test_parent_entity_event(self, computation_test_harness):
sim = computation_test_harness # type: merlin.Simulation
child_ent = merlin.Entity(name="child_ent")
parent_ent = sim.get_entity_by_name("Budget")
sim.add_entity(child_ent)
assert child_ent not in parent_ent.get_children()
assert child_ent.parent is None
a = merlin.Action.create("Entity {0} ^ Entity {1}".format(
child_ent.id, parent_ent.id))
assert len(a) == 1
a[0].execute(sim)
assert child_ent in parent_ent.get_children()
assert child_ent.parent == parent_ent
def test_add_connection_action(self, sim):
source = merlin.Entity(simulation=sim, name='source', attributes=set())
sink = merlin.Entity(simulation=sim, name='sink', attributes=set())
sim.add_entity(source)
sim.add_entity(sink)
aca = merlin.AddConnectionAction(source.id,
sink.id,
'new_unit_type',
apportioning=2,
additive_write=True)
aca.execute(sim)
output_con = source.get_output_by_type('new_unit_type')
input_con = sink.get_input_by_type('new_unit_type')
assert output_con is not None
assert input_con is not None
assert output_con.parent == source
assert input_con.parent == sink
assert len(source.outputs) == 1
assert len(source.inputs) == 0
assert len(sink.inputs) == 1
assert len(sink.outputs) == 0
assert input_con in [ep[0] for ep in output_con.get_endpoints()]
def entity():
"""Returns a vanilla entity object"""
return merlin.Entity(name='test_entity')
