def test_loop_within_infra_possible():
"""
Tests that a loop within the infrastructure is always possible and
does not interfere with other connections. This can be used to embed
multiple consecutive blocks within one node.
"""
infra = InfrastructureNetwork()
nsource = infra.add_source(pos=(0, 0), transmit_power_dbm=30, name="nso")
nsink = infra.set_sink(pos=(1, 0), transmit_power_dbm=30, name="nsi")
overlay = OverlayNetwork()
esource = ENode(overlay.add_source(name="bso"), nsource)
einterm = ENode(overlay.add_intermediate(name="bin"), nsource)
esink = ENode(overlay.set_sink(name="bsi"), nsink)
overlay.add_link(esource.block, einterm.block)
overlay.add_link(einterm.block, esink.block)
embedding = PartialEmbedding(
infra, overlay, source_mapping=[(esource.block, esource.node)]
)
sinr_before = embedding.known_sinr(nsource, nsink, 0)
assert embedding.take_action(esource, einterm, 0)
sinr_after = embedding.known_sinr(nsource, nsink, 0)
assert sinr_before == sinr_after
assert embedding.take_action(einterm, esink, 0)
assert embedding.is_complete()
def test_invalidating_earlier_choice_impossible():
"""
Tests that an action that would invalidate an earlier action is
impossible.
"""
infra = InfrastructureNetwork()
# Two sources, one sink. Equal distance from both sources to sink.
# One source with moderate transmit power (but enough to cover the
# distance, one source with excessive transmit power.
# transmit_power_dbm
# power of 30dBm (similar to a regular router) which should easily
# cover the distance of 1m without any noise.
source_node_silent = infra.add_source(
pos=(0, 0), transmit_power_dbm=20, name="Silent"
)
source_node_screamer = infra.add_source(
pos=(3, 0), transmit_power_dbm=100, name="Screamer"
)
node_sink = infra.set_sink(pos=(1, 3), transmit_power_dbm=0, name="Sink")
overlay = OverlayNetwork()
esource_silent = ENode(overlay.add_source(), source_node_silent)
esource_screamer = ENode(overlay.add_source(), source_node_screamer)
esink = ENode(overlay.set_sink(), node_sink)
overlay.add_link(esource_silent.block, esink.block)
overlay.add_link(esource_screamer.block, esink.block)
embedding = PartialEmbedding(
infra,
overlay,
source_mapping=[
(esource_silent.block, esource_silent.node),
(esource_screamer.block, esource_screamer.node),
],
)
action_to_be_invalidated = (esource_screamer, esink, 0)
# make sure the action is an option in the first place
assert action_to_be_invalidated in embedding.possibilities()
# embed the link from the silent node to the sink
embedding.take_action(esource_silent, esink, 0)
# first assert that action would be valid by itself
screamer_sinr = embedding.known_sinr(source_node_screamer, node_sink, 0)
assert screamer_sinr > 2.0
new_possibilities = embedding.possibilities()
# but since the action would make the first embedding invalid (a
# node cannot receive two signals at the same time), it should still
# not be possible
assert action_to_be_invalidated not in new_possibilities
# since there are no options left in the first timeslot, there are
# now exactly 2 (screamer -> silent as relay, screamer -> sink
# embedded) options left in the newly created second timeslot
assert len(new_possibilities) == 2
def test_broadcast_possible():
"""Tests that broadcast is possible despite SINR constraints"""
infra = InfrastructureNetwork()
# One source, one sink, one intermediate
nsource = infra.add_source(pos=(0, 0), transmit_power_dbm=30)
ninterm = infra.add_intermediate(pos=(1, 2), transmit_power_dbm=30)
nsink = infra.set_sink(pos=(2, 0), transmit_power_dbm=30)
overlay = OverlayNetwork()
esource = ENode(overlay.add_source(), nsource)
einterm = ENode(overlay.add_intermediate(), ninterm)
esink = ENode(overlay.set_sink(), nsink)
# fork
overlay.add_link(esource.block, einterm.block)
overlay.add_link(esource.block, esink.block)
# make complete
overlay.add_link(einterm.block, esink.block)
embedding = PartialEmbedding(
infra, overlay, source_mapping=[(esource.block, esource.node)]
)
# Broadcast from source to sink and intermediate
sinr_before = embedding.known_sinr(esource.node, esink.node, timeslot=0)
assert embedding.take_action(esource, esink, 0)
# Easiest way to test this, easy to change if internals change.
# pylint: disable=protected-access
power_at_sink = embedding.infra.power_at_node(
esink.node, frozenset(embedding._nodes_sending_in[0])
)
assert embedding.take_action(esource, einterm, 0)
# Make sure the broadcasting isn't counted twice
new_power = embedding.infra.power_at_node(
esink.node, frozenset(embedding._nodes_sending_in[0])
)
assert new_power == power_at_sink
# Make sure the broadcasts do not interfere with each other
assert sinr_before == embedding.known_sinr(
esource.node, esink.node, timeslot=0
)
def test_manually_verified_sinr():
"""
Tests that the SINR calculation agrees with a manually verified
example.
"""
infra = InfrastructureNetwork(noise_floor_dbm=15)
# 2 sources, 2 intermediaries, 1 sink
n_source1 = infra.add_source(pos=(0, 0), transmit_power_dbm=30)
n_interm1 = infra.add_intermediate(pos=(1, 0), transmit_power_dbm=30)
n_source2 = infra.add_source(pos=(0, 2), transmit_power_dbm=30)
n_interm2 = infra.add_intermediate(pos=(1, 2), transmit_power_dbm=30)
n_sink = infra.set_sink(pos=(3, 1), transmit_power_dbm=0)
overlay = OverlayNetwork()
b_source1 = overlay.add_source()
b_interm1 = overlay.add_intermediate()
b_source2 = overlay.add_source()
b_interm2 = overlay.add_intermediate()
b_sink = overlay.set_sink()
overlay.add_link(b_source1, b_interm1)
overlay.add_link(b_source2, b_interm2)
# just to make the embedding complete
overlay.add_link(b_interm1, b_sink)
overlay.add_link(b_interm2, b_sink)
embedding = PartialEmbedding(
infra,
overlay,
source_mapping=[(b_source1, n_source1), (b_source2, n_source2)],
)
# this doesn't actually do anything, just makes the next step more
# convenient
e_source1 = ENode(b_source1, n_source1)
e_source2 = ENode(b_source2, n_source2)
e_interm1 = ENode(b_interm1, n_interm1)
e_interm2 = ENode(b_interm2, n_interm2)
e_sink = ENode(b_sink, n_sink)
# Here is the important part: Two signals in parallel
embedding.take_action(e_source1, e_interm1, 0)
embedding.take_action(e_source2, e_interm2, 0)
# We don't really care what is going on in other timeslots, this is
# just to make the embedding valid.
embedding.take_action(e_interm1, e_sink, 1)
embedding.take_action(e_interm2, e_sink, 2)
# Now we have a clean model to work with in timeslot 1: Two parallel
# communications, one signal and one noise.
# Let's calculate the SINR or signal1.
# source1 sends with 30dBm. There is a distance of 1m to interm1.
# According to the log path loss model with a loss exponent of 2
# (appropriate for a building), the signal will incur a loss of
# 2 * distance_decibel dBm
# Where distance_decibel is the distance in relation to 1m, i.e. 0
# in this case. That means there is *no loss*, at least according to
# the model.
# It follows that interm1 receives a signal of 30dBm. Now on to the
# received noise. source2 also sends with 30dBm and has a distance
# of sqrt(1^2 + 2^2) ~= 2.24m to interm1. According to the log path
# loss model:
# distance_decibel = 10 * lg(2.24) ~= 3.50
# => path_loss = 2 * 3.50 ~= 7 dBm
# So interm1 receives roughly 30 - 7 = 23 dBm of noise. Lets assume
# a base noise of 15dB. We have to add those two. Care must be taken
# here because of the logarithmic scale. Naive addition would result
# in multiplication of the actual power in watts. So we need to
# convert back to watts first, then add, then convert back:
# base_noise_milliwatts = 10^(1.5) ~= 31.62 mW
# com_noise_milliwatts = 10^(2.3) ~= 199.53 mW
# => total_noise = 31.62 + 199.53 = 231.15 mW
# The total noise is 231.15 mW, which equals
# 10*lg(231.15) ~= 23.64 dB
# That is way less than the naively calculated 16 + 15 = 31 dB.
# That means the SINR should be
# sinr = 30dBm - 23.64 = 6.36dB
# Here the subtraction actually *should* represent a division of the
# powers.
sinr = embedding.known_sinr(n_source1, n_interm1, 0)
assert sinr == approx(6.36, abs=0.1)