def test_growth():
"""Tests GrowthRegion, ManagerInst, and Source over a 4-time step
simulation.
A linear growth demand (y = x + 2) is provided to the growth region. Two
Sources are allowed in the ManagerInst, with capacities of 2 and 1.1,
respectively. At t=1, a 2-capacity Source is expected to be built, and at
t=2 and t=3, 1-capacity Sources are expected to be built.
"""
holdsrtn = [1] # needed because nose does not send() to test generator
sim_input = "./input/growth.xml"
tmp_file = str(uuid.uuid4()) + ".h5"
cmd = ["cyclus", "-o", tmp_file, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
output = tables.open_file(tmp_file, mode = "r")
# Tables of interest
paths = ["/AgentEntry",]
# Check if these tables exist
yield assert_true, table_exist(output, paths)
if not table_exist(output, paths):
output.close()
if os.path.isfile(tmp_file):
print("removing {0}".format(tmp_file))
os.remove(tmp_file)
return # don't execute further commands
# Get specific tables and columns
agent_entry = output.get_node("/AgentEntry")[:]
# Find agent ids of source and sink facilities
agent_ids = agent_entry["AgentId"]
proto = agent_entry["Prototype"]
depl_time = agent_entry["EnterTime"]
source1_id = find_ids("Source1", proto, agent_ids)
source2_id = find_ids("Source2", proto, agent_ids)
assert_equal(len(source2_id), 1)
assert_equal(len(source1_id), 2)
assert_equal(depl_time[np.where(agent_ids == source2_id[0])], 1)
assert_equal(depl_time[np.where(agent_ids == source1_id[0])], 2)
assert_equal(depl_time[np.where(agent_ids == source1_id[1])], 3)
output.close()
if os.path.isfile(tmp_file):
print("removing {0}".format(tmp_file))
os.remove(tmp_file)
def check_null_sink(fname, given_spec):
"""Testing for null sink case without a source facility.
No transactions are expected in this test; therefore, a table with
transaction records must not exist in order to pass this test.
"""
clean_outs()
if not cyclus_has_coin():
raise SkipTest("Cyclus does not have COIN")
# Cyclus simulation input for null sink testing
sim_input = os.path.join(INPUT, fname)
holdsrtn = [1] # needed because nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
legal_paths = ["/AgentEntry", "/Info"]
illegal_paths = ["/Transactions"] # this must contain tables to test
# Check if these tables exist
yield assert_true, tables_exist(outfile, legal_paths)
if not tables_exist(outfile, legal_paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific data
if outfile == h5out:
output = tables.open_file(h5out, mode="r")
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
output.close()
else:
conn = sqlite3.connect(outfile)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
conn.close()
# Sink's deployment
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
sink_id = find_ids(given_spec, spec, agent_ids)
# Test if one SimpleSink is deployed
yield assert_equal, len(sink_id), 1
# No resource exchange is expected
yield assert_false, tables_exist(outfile, illegal_paths)
clean_outs()
def check_null_sink(fname, given_spec):
"""Testing for null sink case without a source facility.
No transactions are expected in this test; therefore, a table with
transaction records must not exist in order to pass this test.
"""
clean_outs()
if not cyclus_has_coin():
raise SkipTest("Cyclus does not have COIN")
# Cyclus simulation input for null sink testing
sim_input = os.path.join(INPUT, fname)
holdsrtn = [1] # needed because nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
legal_paths = ["/AgentEntry", "/Info"]
illegal_paths = ["/Transactions"] # this must contain tables to test
# Check if these tables exist
yield assert_true, tables_exist(outfile, legal_paths)
if not tables_exist(outfile, legal_paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific data
if outfile == h5out:
output = tables.open_file(h5out, mode = "r")
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
output.close()
else:
conn = sqlite3.connect(outfile)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
conn.close()
# Sink's deployment
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
sink_id = find_ids(given_spec, spec, agent_ids)
# Test if one SimpleSink is deployed
yield assert_equal, len(sink_id), 1
# No resource exchange is expected
yield assert_false, tables_exist(outfile, illegal_paths)
clean_outs()
def test_stub_example():
"""Testing for the stubs example."""
clean_outs()
# Cyclus simulation input for null sink testing
sim_input = "./input/stub_example.xml"
holdsrtn = [1] # needed because nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, os.getcwd(), holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
legal_paths = ["/AgentEntry", "/Info"]
illegal_paths = ["/Transactions"] # this must contain tables to test
# Check if these tables exist
yield assert_true, tables_exist(outfile, legal_paths)
if not tables_exist(outfile, legal_paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific data
if outfile == h5out:
output = tables.open_file(h5out, mode = "r")
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
output.close()
else:
conn = sqlite3.connect(sqliteout)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
conn.close()
# Sink's deployment
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
sink_id = find_ids("stubs:StubFacility:StubFacility", spec, agent_ids)
# Test if one SimpleSink is deployed
yield assert_equal, len(sink_id), 1
# No resource exchange is expected
yield assert_false, tables_exist(outfile, illegal_paths)
clean_outs()
def test_stub_example():
"""Testing for the stubs example."""
clean_outs()
# Cyclus simulation input for null sink testing
sim_input = "./input/stub_example.xml"
holdsrtn = [1] # needed because nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, os.getcwd(), holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
legal_paths = ["/AgentEntry", "/Info"]
illegal_paths = ["/Transactions"] # this must contain tables to test
# Check if these tables exist
yield assert_true, tables_exist(outfile, legal_paths)
if not tables_exist(outfile, legal_paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific data
if outfile == h5out:
output = tables.open_file(h5out, mode="r")
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
output.close()
else:
conn = sqlite3.connect(sqliteout)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
conn.close()
# Sink's deployment
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
sink_id = find_ids("stubs:StubFacility:StubFacility", spec, agent_ids)
# Test if one SimpleSink is deployed
yield assert_equal, len(sink_id), 1
# No resource exchange is expected
yield assert_false, tables_exist(outfile, illegal_paths)
clean_outs()
def test_null_sink():
"""Testing for null sink case without a source facility.
No transactions are expected in this test; therefore, a table with
transaction records must not exist in order to pass this test.
"""
clean_outs()
# Cyclus simulation input for null sink testing
sim_input = "./input/null_sink.xml"
holdsrtn = [1] # needed because nose does not send() to test generator
cmd = ["cyclus", "-o", h5out, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
output = tables.open_file(h5out, mode = "r")
legal_paths = ["/AgentEntry", "/Info"]
illegal_paths = ["/Transactions"] # this must contain tables to test
# Check if these tables exist
yield assert_true, tables_exist(output, legal_paths)
if not tables_exist(output, legal_paths):
output.close()
clean_outs()
return # don't execute further commands
# Get specific data
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
# Sink's deployment
agent_ids = agent_entry["AgentId"]
spec = agent_entry["Spec"]
sink_id = find_ids(":agents:Sink", spec, agent_ids)
# Test if one SimpleSink is deployed
yield assert_equal, len(sink_id), 1
# No resource exchange is expected
yield assert_false, tables_exist(output, illegal_paths)
output.close()
clean_outs()
def test_minimal_cycle():
"""Tests simulations with two facilities with several conversion factors.
The commodities of the facilities are different. Facility A offers a
commodity A and requests commodity B; whereas, Facility B offers a
commodity B and requests commodity A. In addition, it is also assumed that
the first requests and offers are the same quantities for respective
receivers and senders.
The amount of the transactions follow a power law.
Amount = InitialAmount * ConversionFactor ^ Time
This equation is used to test each transaction amount.
"""
# A reference simulation input for minimal cycle with different commodities
ref_input = "./input/minimal_cycle.xml"
# Conversion factors for the simulations
k_factors = [0.95, 1, 2]
for k_factor_a in k_factors:
for k_factor_b in k_factors:
clean_outs()
sim_input = change_minimal_input(ref_input, k_factor_a, k_factor_b)
holdsrtn = [1] # needed b/c nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
# tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions",
"/Info"]
# Check if these tables exist
yield assert_true, tables_exist(outfile, paths)
if not tables_exist(outfile, paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific tables and columns
if outfile == h5out:
output = tables.open_file(h5out, mode = "r")
agent_entry = output.root.AgentEntry[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
output.close()
else:
conn = sqlite3.connect(sqliteout)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
resources = exc('SELECT * FROM Resources').fetchall()
transactions = exc('SELECT * FROM Transactions').fetchall()
conn.close()
# Find agent ids
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
agent_protos = to_ary(agent_entry, "Prototype")
duration = to_ary(info, "Duration")[0]
facility_id = find_ids(":agents:KFacility", spec, agent_ids)
# Test for two KFacility
yield assert_equal, len(facility_id), 2
# Test for one Facility A and Facility B
facility_a = find_ids("FacilityA", agent_protos, agent_ids)
facility_b = find_ids("FacilityB", agent_protos, agent_ids)
yield assert_equal, len(facility_a), 1
yield assert_equal, len(facility_b), 1
# Test if both facilities are KFracilities
# Assume FacilityA is deployed first according to the schema
yield assert_equal, facility_a[0], facility_id[0]
yield assert_equal, facility_b[0], facility_id[1]
# Test if the transactions are strictly between Facility A and
# Facility B. There are no Facility A to Facility A or vice versa.
sender_ids = to_ary(transactions, "SenderId")
receiver_ids = to_ary(transactions, "ReceiverId")
pattern_one = np.arange(0, sender_ids.size, 2)
pattern_two = np.arange(1, sender_ids.size, 2)
pattern_a = pattern_one # expected pattern for Facility A as sender
pattern_b = pattern_two # expected pattern for Facility B as sender
# Re-assign in case the expected patterns are incorrect
if sender_ids[0] == facility_b[0]:
pattern_a = pattern_two
pattern_b = pattern_one
yield assert_array_equal, \
np.where(sender_ids == facility_a[0])[0], \
pattern_a, "Fac A Pattern A"
yield assert_array_equal, \
np.where(receiver_ids == facility_a[0])[0], \
pattern_b, "Fac A Pattern B" # reverse pattern when acted as a receiver
yield assert_array_equal, \
np.where(sender_ids == facility_b[0])[0], \
pattern_b, "Fac B Pattern A"
yield assert_array_equal, \
np.where(receiver_ids == facility_b[0])[0], \
pattern_a, "Fac B Pattern B" # reverse pattern when acted as a receiver
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(sender_ids.size)
yield assert_array_equal, \
to_ary(transactions, "TransactionId"), \
expected_trans_ids
# When k_factors are very low and the simulation time is big
# the number of transactions maybe shortened due to the lower
# limit cyclus::eps() for transaction amounts.
# Expect not to have shortened transactions, so for two facilities,
# there must be (2 * duration) number of transactions.
exp = 2 * duration
obs = sender_ids.size
yield assert_equal, exp, obs, "number of transactions, {} != {}".format(exp, obs)
# Track transacted resources
quantities = to_ary(resources, "Quantity")
# Almost equal cases due to floating point k_factors
init_capacity_a = quantities[0]
init_capacity_b = quantities[1]
j = 0
for p in pattern_a:
yield assert_almost_equal, quantities[p], \
init_capacity_a * k_factor_a ** j
j += 1
j = 0
for p in pattern_b:
yield assert_almost_equal, quantities[p], \
init_capacity_b * k_factor_b ** j
j += 1
clean_outs()
os.remove(sim_input)
def test_source_to_sink():
"""Tests simulations with one facility that has a conversion factor.
The trivial cycle simulation involves only one KFacility which provides
what it requests itself. The conversion factors for requests and bids
are kept the same so that the facility provides exactly what it requests.
The amount of the transactions follow a power law.
Amount = InitialAmount * ConversionFactor ^ Time
This equation is used to test each transaction amount.
"""
# A reference simulation input for the trivial cycle simulation.
ref_input = "./input/trivial_cycle.xml"
# Conversion factors for the three simulations
k_factors = [0.95, 1, 2]
for k_factor in k_factors:
clean_outs()
sim_input = create_sim_input(ref_input, k_factor, k_factor)
holdsrtn = [1] # needed because nose does not send() to test generator
cmd = ["cyclus", "-o", h5out, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
output = tables.open_file(h5out, mode = "r")
# tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions",
"/Info"]
# Check if these tables exist
yield assert_true, tables_exist(output, paths)
if not tables_exist(output, paths):
output.close()
clean_outs()
return # don't execute further commands
# Get specific tables and columns
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
# Find agent ids
agent_ids = agent_entry["AgentId"]
spec = agent_entry["Spec"]
facility_id = find_ids(":agents:KFacility", spec, agent_ids)
# Test for only one KFacility
yield assert_equal, len(facility_id), 1
sender_ids = transactions["SenderId"]
receiver_ids = transactions["ReceiverId"]
expected_sender_array = np.empty(sender_ids.size)
expected_sender_array.fill(facility_id[0])
expected_receiver_array = np.empty(receiver_ids.size)
expected_receiver_array.fill(facility_id[0])
yield assert_array_equal, sender_ids, expected_sender_array
yield assert_array_equal, receiver_ids, expected_receiver_array
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(0, sender_ids.size, 1)
yield assert_array_equal, transactions["TransactionId"], expected_trans_ids
# Track transacted resources
resource_ids = resources["ResourceId"]
quantities = resources["Quantity"]
# Almost equal cases due to floating point k_factors
i = 0
initial_capacity = quantities[0]
for q in quantities:
yield assert_almost_equal, q, initial_capacity * k_factor ** i
i += 1
output.close()
clean_outs()
os.remove(sim_input)
def test_source_to_sink():
"""Tests linear growth of sink inventory by checking if the transactions
were of equal quantities and only between sink and source facilities.
"""
clean_outs()
# Cyclus simulation input for Source and Sink
sim_inputs = ["./input/source_to_sink.xml"]
for sim_input in sim_inputs:
holdsrtn = [1] # needed because nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
# Tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions", "/Info"]
# Check if these tables exist
yield assert_true, tables_exist(outfile, paths)
if not tables_exist(outfile, paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific tables and columns
if outfile == h5out:
output = tables.open_file(h5out, mode="r")
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
output.close()
else:
conn = sqlite3.connect(outfile)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
resources = exc('SELECT * FROM Resources').fetchall()
transactions = exc('SELECT * FROM Transactions').fetchall()
conn.close()
# Find agent ids of source and sink facilities
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
source_id = find_ids(":agents:Source", spec, agent_ids)
sink_id = find_ids(":agents:Sink", spec, agent_ids)
# Test for only one source and one sink are deployed in the simulation
yield assert_equal, len(source_id), 1
yield assert_equal, len(sink_id), 1
# Check if transactions are only between source and sink
sender_ids = to_ary(transactions, "SenderId")
receiver_ids = to_ary(transactions, "ReceiverId")
expected_sender_array = np.empty(sender_ids.size)
expected_sender_array.fill(source_id[0])
expected_receiver_array = np.empty(receiver_ids.size)
expected_receiver_array.fill(sink_id[0])
yield assert_array_equal, sender_ids, expected_sender_array
yield assert_array_equal, receiver_ids, expected_receiver_array
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(0, sender_ids.size, 1)
yield assert_array_equal, \
to_ary(transactions, "TransactionId"),\
expected_trans_ids
# Track transacted resources
resource_ids = to_ary(resources, "ResourceId")
quantities = to_ary(resources, "Quantity")
expected_quantities = np.empty(resource_ids.size)
# Expect that every transaction quantity is the same amount
expected_quantities.fill(quantities[0])
yield assert_array_equal, quantities, expected_quantities
clean_outs()
def test_source_to_sink():
"""Tests linear growth of sink inventory by checking if the transactions
were of equal quantities and only between sink and source facilities.
"""
clean_outs()
# Cyclus simulation input for Source and Sink
sim_inputs = ["./input/source_to_sink.xml"]
for sim_input in sim_inputs:
holdsrtn = [1] # needed because nose does not send() to test generator
cmd = ["cyclus", "-o", h5out, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
output = tables.open_file(h5out, mode="r")
# Tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions", "/Info"]
# Check if these tables exist
yield assert_true, tables_exist(output, paths)
if not tables_exist(output, paths):
output.close()
clean_outs()
return # don't execute further commands
# Get specific tables and columns
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
# Find agent ids of source and sink facilities
agent_ids = agent_entry["AgentId"]
spec = agent_entry["Spec"]
source_id = find_ids(":agents:Source", spec, agent_ids)
sink_id = find_ids(":agents:Sink", spec, agent_ids)
# Test for only one source and one sink are deployed in the simulation
yield assert_equal, len(source_id), 1
yield assert_equal, len(sink_id), 1
# Check if transactions are only between source and sink
sender_ids = transactions["SenderId"]
receiver_ids = transactions["ReceiverId"]
expected_sender_array = np.empty(sender_ids.size)
expected_sender_array.fill(source_id[0])
expected_receiver_array = np.empty(receiver_ids.size)
expected_receiver_array.fill(sink_id[0])
yield assert_array_equal, sender_ids, expected_sender_array
yield assert_array_equal, receiver_ids, expected_receiver_array
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(0, sender_ids.size, 1)
yield assert_array_equal, transactions[
"TransactionId"], expected_trans_ids
# Track transacted resources
resource_ids = resources["ResourceId"]
quantities = resources["Quantity"]
expected_quantities = np.empty(resource_ids.size)
# Expect that every transaction quantity is the same amount
expected_quantities.fill(quantities[0])
yield assert_array_equal, quantities, expected_quantities
output.close()
clean_outs()
def find_ids(self, spec, a, spec_col="Spec", id_col="AgentId"):
if self.ext == '.h5':
return helper.find_ids(spec, a[spec_col], a[id_col])
else:
return [x[id_col] for x in a if x[spec_col] == spec]
def test_minimal_cycle():
"""Tests simulations with two facilities with several conversion factors.
The commodities of the facilities are different. Facility A offers a
commodity A and requests commodity B; whereas, Facility B offers a
commodity B and requests commodity A. In addition, it is also assumed that
the first requests and offers are the same quantities for respective
receivers and senders.
The amount of the transactions follow a power law.
Amount = InitialAmount * ConversionFactor ^ Time
This equation is used to test each transaction amount.
"""
# A reference simulation input for minimal cycle with different commodities
ref_input = "./input/minimal_cycle.xml"
# Conversion factors for the simulations
k_factors = [0.95, 1, 2]
for k_factor_a in k_factors:
for k_factor_b in k_factors:
clean_outs()
sim_input = change_minimal_input(ref_input, k_factor_a, k_factor_b)
holdsrtn = [1] # needed b/c nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
# tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions", "/Info"]
# Check if these tables exist
yield assert_true, tables_exist(outfile, paths)
if not tables_exist(outfile, paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific tables and columns
if outfile == h5out:
output = tables.open_file(h5out, mode="r")
agent_entry = output.root.AgentEntry[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
output.close()
else:
conn = sqlite3.connect(sqliteout)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
resources = exc('SELECT * FROM Resources').fetchall()
transactions = exc('SELECT * FROM Transactions').fetchall()
conn.close()
# Find agent ids
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
agent_protos = to_ary(agent_entry, "Prototype")
duration = to_ary(info, "Duration")[0]
facility_id = find_ids(":agents:KFacility", spec, agent_ids)
# Test for two KFacility
yield assert_equal, len(facility_id), 2
# Test for one Facility A and Facility B
facility_a = find_ids("FacilityA", agent_protos, agent_ids)
facility_b = find_ids("FacilityB", agent_protos, agent_ids)
yield assert_equal, len(facility_a), 1
yield assert_equal, len(facility_b), 1
# Test if both facilities are KFracilities
# Assume FacilityA is deployed first according to the schema
yield assert_equal, facility_a[0], facility_id[0]
yield assert_equal, facility_b[0], facility_id[1]
# Test if the transactions are strictly between Facility A and
# Facility B. There are no Facility A to Facility A or vice versa.
sender_ids = to_ary(transactions, "SenderId")
receiver_ids = to_ary(transactions, "ReceiverId")
pattern_one = np.arange(0, sender_ids.size, 2)
pattern_two = np.arange(1, sender_ids.size, 2)
pattern_a = pattern_one # expected pattern for Facility A as sender
pattern_b = pattern_two # expected pattern for Facility B as sender
# Re-assign in case the expected patterns are incorrect
if sender_ids[0] == facility_b[0]:
pattern_a = pattern_two
pattern_b = pattern_one
yield assert_array_equal, \
np.where(sender_ids == facility_a[0])[0], \
pattern_a
yield assert_array_equal, \
np.where(receiver_ids == facility_a[0])[0], \
pattern_b # reverse pattern when acted as a receiver
yield assert_array_equal, \
np.where(sender_ids == facility_b[0])[0], \
pattern_b
yield assert_array_equal, \
np.where(receiver_ids == facility_b[0])[0], \
pattern_a # reverse pattern when acted as a receiver
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(sender_ids.size)
yield assert_array_equal, \
to_ary(transactions, "TransactionId"), \
expected_trans_ids
# When k_factors are very low and the simulation time is big
# the number of transactions maybe shortened due to the lower
# limit cyclus::eps() for transaction amounts.
# Expect not to have shortened transactions, so for two facilities,
# there must be (2 * duration) number of transactions.
yield assert_equal, sender_ids.size, 2 * duration
# Track transacted resources
quantities = to_ary(resources, "Quantity")
# Almost equal cases due to floating point k_factors
init_capacity_a = quantities[0]
init_capacity_b = quantities[1]
j = 0
for p in pattern_a:
yield assert_almost_equal, quantities[p], \
init_capacity_a * k_factor_a ** j
j += 1
j = 0
for p in pattern_b:
yield assert_almost_equal, quantities[p], \
init_capacity_b * k_factor_b ** j
j += 1
clean_outs()
os.remove(sim_input)
def test_dynamic_capacitated():
"""Tests dynamic capacity restraints involving changes in the number of
source and sink facilities.
A source facility is expected to offer a commodity of amount 1,
and a sink facility is expected to request for a commodity of amount 1.
Therefore, number of facilities correspond to the amounts of offers
and requests.
At time step 1, 3 source facilities and 2 sink facilities are deployed, and
at time step 2, additional 2 sink facilities are deployed. After time
step 2, the older 2 sink facilities are decommissioned.
According to this deployment schedule, at time step 1, only 2 transactions
are expected, the number of sink facilities being the constraint; whereas,
at time step 2, only 3 transactions are expected, the number of source
facilities being the constraint. At time step 3, after decommissioning 2
older sink facilities, the remaining number of sink facilities becomes
the constraint, resulting in the same transaction amount as in time step 1.
"""
# Cyclus simulation input for dynamic capacitated
sim_inputs = ["./input/dynamic_capacitated.xml"]
for sim_input in sim_inputs:
holdsrtn = [1] # needed because nose does not send() to test generator
tmp_file = str(uuid.uuid4()) + ".h5"
cmd = ["cyclus", "-o", tmp_file, "--input-file", sim_input]
yield check_cmd, cmd, ".", holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
output = tables.open_file(tmp_file, mode="r")
# Tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions", "/AgentExit"]
# Check if these tables exist
yield assert_true, table_exist(output, paths)
if not table_exist(output, paths):
output.close()
if os.path.isfile(tmp_file):
print("removing {0}".format(tmp_file))
os.remove(tmp_file)
return # don't execute further commands
# Get specific tables and columns
agent_entry = output.get_node("/AgentEntry")[:]
agent_exit = output.get_node("/AgentExit")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
# Find agent ids of source and sink facilities
agent_ids = agent_entry["AgentId"]
agent_impl = agent_entry["Spec"]
depl_time = agent_entry["EnterTime"]
exit_time = agent_exit["ExitTime"]
exit_ids = agent_exit["AgentId"]
source_id = find_ids(":agents:Source", agent_impl, agent_ids)
sink_id = find_ids(":agents:Sink", agent_impl, agent_ids)
# Test for 3 sources and 4 sinks are deployed in the simulation
yield assert_equal, len(source_id), 3
yield assert_equal, len(sink_id), 4
# Test that source facilities are all deployed at time step 1
for s in source_id:
yield assert_equal, depl_time[np.where(agent_ids == s)], 1
# Test that first 2 sink facilities are deployed at time step 1
# and decommissioned at time step 2
for i in [0, 1]:
yield assert_equal, depl_time[np.where(agent_ids == sink_id[i])], 1
yield assert_equal, exit_time[np.where(exit_ids == sink_id[i])], 2
# Test that second 2 sink facilities are deployed at time step 2
# and decommissioned at time step 3
for i in [2, 3]:
yield assert_equal, depl_time[np.where(agent_ids == sink_id[i])], 2
yield assert_equal, exit_time[np.where(exit_ids == sink_id[i])], 3
# Check transactions
sender_ids = transactions["SenderId"]
receiver_ids = transactions["ReceiverId"]
trans_time = transactions["Time"]
trans_resource = transactions["ResourceId"]
# Track transacted resources
resource_ids = resources["ResourceId"]
quantities = resources["Quantity"]
# Check that transactions are between sources and sinks only
for s in sender_ids:
yield assert_equal, len(np.where(source_id == s)[0]), 1
for r in receiver_ids:
yield assert_equal, len(np.where(sink_id == r)[0]), 1
# Total expected number of transactions
yield assert_equal, len(trans_time), 7
# Check that at time step 1, there are 2 transactions
yield assert_equal, len(np.where(trans_time == 1)[0]), 2
# Check that at time step 2, there are 3 transactions
yield assert_equal, len(np.where(trans_time == 2)[0]), 3
# Check that at time step 3, there are 2 transactions
yield assert_equal, len(np.where(trans_time == 3)[0]), 2
# Check that at time step 1, there are 2 transactions with total
# amount of 2
quantity = 0
for t in np.where(trans_time == 1)[0]:
quantity += quantities[np.where(resource_ids == trans_resource[t])]
yield assert_equal, quantity, 2
# Check that at time step 2, there are 3 transactions with total
# amount of 3
quantity = 0
for t in np.where(trans_time == 2)[0]:
quantity += quantities[np.where(resource_ids == trans_resource[t])]
yield assert_equal, quantity, 3
# Check that at time step 3, there are 2 transactions with total
# amount of 2
quantity = 0
for t in np.where(trans_time == 3)[0]:
quantity += quantities[np.where(resource_ids == trans_resource[t])]
yield assert_equal, quantity, 2
output.close()
if os.path.isfile(tmp_file):
print("removing {0}".format(tmp_file))
os.remove(tmp_file)
def check_source_to_sink(fname, source_spec, sink_spec):
"""Tests linear growth of sink inventory by checking if the transactions
were of equal quantities and only between sink and source facilities.
"""
clean_outs()
if not cyclus_has_coin():
raise SkipTest("Cyclus does not have COIN")
# Cyclus simulation input for Source and Sink
sim_inputs = [os.path.join(INPUT, fname)]
for sim_input in sim_inputs:
holdsrtn = [1] # needed because nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
# Tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions", "/Info"]
# Check if these tables exist
yield assert_true, tables_exist(outfile, paths)
if not tables_exist(outfile, paths):
clean_outs()
return # don't execute further commands
# Get specific tables and columns
if outfile == h5out:
output = tables.open_file(h5out, mode = "r")
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
output.close()
else:
conn = sqlite3.connect(outfile)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
resources = exc('SELECT * FROM Resources').fetchall()
transactions = exc('SELECT * FROM Transactions').fetchall()
conn.close()
# Find agent ids of source and sink facilities
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
source_id = find_ids(source_spec, spec, agent_ids)
sink_id = find_ids(sink_spec, spec, agent_ids)
# Test for only one source and one sink are deployed in the simulation
yield assert_equal, len(source_id), 1
yield assert_equal, len(sink_id), 1
# Check if transactions are only between source and sink
sender_ids = to_ary(transactions, "SenderId")
receiver_ids = to_ary(transactions, "ReceiverId")
expected_sender_array = np.empty(sender_ids.size)
expected_sender_array.fill(source_id[0])
expected_receiver_array = np.empty(receiver_ids.size)
expected_receiver_array.fill(sink_id[0])
yield assert_array_equal, sender_ids, expected_sender_array
yield assert_array_equal, receiver_ids, expected_receiver_array
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(0, sender_ids.size, 1)
yield assert_array_equal, \
to_ary(transactions, "TransactionId"),\
expected_trans_ids
# Track transacted resources
resource_ids = to_ary(resources, "ResourceId")
quantities = to_ary(resources, "Quantity")
expected_quantities = np.empty(resource_ids.size)
# Expect that every transaction quantity is the same amount
expected_quantities.fill(quantities[0])
yield assert_array_equal, quantities, expected_quantities
clean_outs()
def test_source_to_sink():
"""Tests simulations with one facility that has a conversion factor.
The trivial cycle simulation involves only one KFacility which provides
what it requests itself. The conversion factors for requests and bids
are kept the same so that the facility provides exactly what it requests.
The amount of the transactions follow a power law.
Amount = InitialAmount * ConversionFactor ^ Time
This equation is used to test each transaction amount.
"""
# A reference simulation input for the trivial cycle simulation.
ref_input = "./input/trivial_cycle.xml"
# Conversion factors for the three simulations
k_factors = [0.95, 1, 2]
for k_factor in k_factors:
clean_outs()
sim_input = create_sim_input(ref_input, k_factor, k_factor)
holdsrtn = [1] # needed because nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
# tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions", "/Info"]
# Check if these tables exist
yield assert_true, tables_exist(outfile, paths)
if not tables_exist(outfile, paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific tables and columns
if outfile == h5out:
output = tables.open_file(h5out, mode="r")
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
output.close()
else:
conn = sqlite3.connect(sqliteout)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
resources = exc('SELECT * FROM Resources').fetchall()
transactions = exc('SELECT * FROM Transactions').fetchall()
conn.close()
# Find agent ids
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
facility_id = find_ids(":agents:KFacility", spec, agent_ids)
# Test for only one KFacility
yield assert_equal, len(facility_id), 1
sender_ids = to_ary(transactions, "SenderId")
receiver_ids = to_ary(transactions, "ReceiverId")
expected_sender_array = np.empty(sender_ids.size)
expected_sender_array.fill(facility_id[0])
expected_receiver_array = np.empty(receiver_ids.size)
expected_receiver_array.fill(facility_id[0])
yield assert_array_equal, sender_ids, expected_sender_array
yield assert_array_equal, receiver_ids, expected_receiver_array
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(0, sender_ids.size, 1)
yield assert_array_equal, \
to_ary(transactions, "TransactionId"), \
expected_trans_ids
# Track transacted resources
resource_ids = to_ary(resources, "ResourceId")
quantities = to_ary(resources, "Quantity")
# Almost equal cases due to floating point k_factors
i = 0
initial_capacity = quantities[0]
for q in quantities:
yield assert_almost_equal, q, initial_capacity * k_factor**i
i += 1
clean_outs()
os.remove(sim_input)
def test_source_to_sink():
"""Tests simulations with one facility that has a conversion factor.
The trivial cycle simulation involves only one KFacility which provides
what it requests itself. The conversion factors for requests and bids
are kept the same so that the facility provides exactly what it requests.
The amount of the transactions follow a power law.
Amount = InitialAmount * ConversionFactor ^ Time
This equation is used to test each transaction amount.
"""
if not cyclus_has_coin():
raise SkipTest("Cyclus does not have COIN")
# A reference simulation input for the trivial cycle simulation.
ref_input = os.path.join(INPUT, "trivial_cycle.xml")
# Conversion factors for the three simulations
k_factors = [0.95, 1, 2]
for k_factor in k_factors:
clean_outs()
sim_input = create_sim_input(ref_input, k_factor, k_factor)
holdsrtn = [1] # needed because nose does not send() to test generator
outfile = which_outfile()
cmd = ["cyclus", "-o", outfile, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
# tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions",
"/Info"]
# Check if these tables exist
yield assert_true, tables_exist(outfile, paths)
if not tables_exist(outfile, paths):
outfile.close()
clean_outs()
return # don't execute further commands
# Get specific tables and columns
if outfile == h5out:
output = tables.open_file(h5out, mode = "r")
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
output.close()
else:
conn = sqlite3.connect(sqliteout)
conn.row_factory = sqlite3.Row
cur = conn.cursor()
exc = cur.execute
agent_entry = exc('SELECT * FROM AgentEntry').fetchall()
info = exc('SELECT * FROM Info').fetchall()
resources = exc('SELECT * FROM Resources').fetchall()
transactions = exc('SELECT * FROM Transactions').fetchall()
conn.close()
# Find agent ids
agent_ids = to_ary(agent_entry, "AgentId")
spec = to_ary(agent_entry, "Spec")
facility_id = find_ids(":agents:KFacility", spec, agent_ids)
# Test for only one KFacility
yield assert_equal, len(facility_id), 1
sender_ids = to_ary(transactions, "SenderId")
receiver_ids = to_ary(transactions, "ReceiverId")
expected_sender_array = np.empty(sender_ids.size)
expected_sender_array.fill(facility_id[0])
expected_receiver_array = np.empty(receiver_ids.size)
expected_receiver_array.fill(facility_id[0])
yield assert_array_equal, sender_ids, expected_sender_array
yield assert_array_equal, receiver_ids, expected_receiver_array
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(0, sender_ids.size, 1)
yield assert_array_equal, \
to_ary(transactions, "TransactionId"), \
expected_trans_ids
# Track transacted resources
resource_ids = to_ary(resources, "ResourceId")
quantities = to_ary(resources, "Quantity")
# Almost equal cases due to floating point k_factors
i = 0
initial_capacity = quantities[0]
for q in quantities:
yield assert_almost_equal, q, initial_capacity * k_factor ** i
i += 1
clean_outs()
os.remove(sim_input)
def test_source_to_sink():
"""Tests linear growth of sink inventory by checking if the transactions
were of equal quantities and only between sink and source facilities.
"""
clean_outs()
# Cyclus simulation input for Source and Sink
sim_inputs = ["./input/source_to_sink.xml"]
for sim_input in sim_inputs:
holdsrtn = [1] # needed because nose does not send() to test generator
cmd = ["cyclus", "-o", h5out, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
output = tables.open_file(h5out, mode = "r")
# Tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions", "/Info"]
# Check if these tables exist
yield assert_true, tables_exist(output, paths)
if not tables_exist(output, paths):
output.close()
clean_outs()
return # don't execute further commands
# Get specific tables and columns
agent_entry = output.get_node("/AgentEntry")[:]
info = output.get_node("/Info")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
# Find agent ids of source and sink facilities
agent_ids = agent_entry["AgentId"]
spec = agent_entry["Spec"]
source_id = find_ids(":agents:Source", spec, agent_ids)
sink_id = find_ids(":agents:Sink", spec, agent_ids)
# Test for only one source and one sink are deployed in the simulation
yield assert_equal, len(source_id), 1
yield assert_equal, len(sink_id), 1
# Check if transactions are only between source and sink
sender_ids = transactions["SenderId"]
receiver_ids = transactions["ReceiverId"]
expected_sender_array = np.empty(sender_ids.size)
expected_sender_array.fill(source_id[0])
expected_receiver_array = np.empty(receiver_ids.size)
expected_receiver_array.fill(sink_id[0])
yield assert_array_equal, sender_ids, expected_sender_array
yield assert_array_equal, receiver_ids, expected_receiver_array
# Transaction ids must be equal range from 1 to the number of rows
expected_trans_ids = np.arange(0, sender_ids.size, 1)
yield assert_array_equal, transactions["TransactionId"], expected_trans_ids
# Track transacted resources
resource_ids = resources["ResourceId"]
quantities = resources["Quantity"]
expected_quantities = np.empty(resource_ids.size)
# Expect that every transaction quantity is the same amount
expected_quantities.fill(quantities[0])
yield assert_array_equal, quantities, expected_quantities
output.close()
clean_outs()
def find_ids(self, spec, a, spec_col="Spec", id_col="AgentId"):
if self.ext == '.h5':
return helper.find_ids(spec, a[spec_col], a[id_col])
else:
return [x[id_col] for x in a if x[spec_col] == spec]
def test_dynamic_capacitated():
"""Tests dynamic capacity restraints involving changes in the number of
source and sink facilities.
A source facility is expected to offer a commodity of amount 1,
and a sink facility is expected to request for a commodity of amount 1.
Therefore, number of facilities correspond to the amounts of offers
and requests.
At time step 1, 3 source facilities and 2 sink facilities are deployed, and
at time step 2, additional 2 sink facilities are deployed. After time
step 2, the older 2 sink facilities are decommissioned.
According to this deployment schedule, at time step 1, only 2 transactions
are expected, the number of sink facilities being the constraint; whereas,
at time step 2, only 3 transactions are expected, the number of source
facilities being the constraint. At time step 3, after decommissioning 2
older sink facilities, the remaining number of sink facilities becomes
the constraint, resulting in the same transaction amount as in time step 1.
"""
# Cyclus simulation input for dynamic capacitated
sim_inputs = ["./input/dynamic_capacitated.xml"]
for sim_input in sim_inputs:
holdsrtn = [1] # needed because nose does not send() to test generator
tmp_file = str(uuid.uuid4()) + ".h5"
cmd = ["cyclus", "-o", tmp_file, "--input-file", sim_input]
yield check_cmd, cmd, '.', holdsrtn
rtn = holdsrtn[0]
if rtn != 0:
return # don't execute further commands
output = tables.open_file(tmp_file, mode = "r")
# Tables of interest
paths = ["/AgentEntry", "/Resources", "/Transactions", "/AgentExit"]
# Check if these tables exist
yield assert_true, table_exist(output, paths)
if not table_exist(output, paths):
output.close()
if os.path.isfile(tmp_file):
print("removing {0}".format(tmp_file))
os.remove(tmp_file)
return # don't execute further commands
# Get specific tables and columns
agent_entry = output.get_node("/AgentEntry")[:]
agent_exit = output.get_node("/AgentExit")[:]
resources = output.get_node("/Resources")[:]
transactions = output.get_node("/Transactions")[:]
# Find agent ids of source and sink facilities
agent_ids = agent_entry["AgentId"]
agent_impl = agent_entry["Spec"]
depl_time = agent_entry["EnterTime"]
exit_time = agent_exit["ExitTime"]
exit_ids = agent_exit["AgentId"]
source_id = find_ids(":agents:Source", agent_impl, agent_ids)
sink_id = find_ids(":agents:Sink", agent_impl, agent_ids)
# Test for 3 sources and 4 sinks are deployed in the simulation
yield assert_equal, len(source_id), 3
yield assert_equal, len(sink_id), 4
# Test that source facilities are all deployed at time step 1
for s in source_id:
yield assert_equal, depl_time[np.where(agent_ids == s)], 1
# Test that first 2 sink facilities are deployed at time step 1
# and decommissioned at time step 2
for i in [0, 1]:
yield assert_equal,\
depl_time[np.where(agent_ids == sink_id[i])], 1
yield assert_equal,\
exit_time[np.where(exit_ids == sink_id[i])], 2
# Test that second 2 sink facilities are deployed at time step 2
# and decommissioned at time step 3
for i in [2, 3]:
yield assert_equal,\
depl_time[np.where(agent_ids == sink_id[i])], 2
yield assert_equal,\
exit_time[np.where(exit_ids == sink_id[i])], 3
# Check transactions
sender_ids = transactions["SenderId"]
receiver_ids = transactions["ReceiverId"]
trans_time = transactions["Time"]
trans_resource = transactions["ResourceId"]
# Track transacted resources
resource_ids = resources["ResourceId"]
quantities = resources["Quantity"]
# Check that transactions are between sources and sinks only
for s in sender_ids:
yield assert_equal, len(np.where(source_id == s)[0]), 1
for r in receiver_ids:
yield assert_equal, len(np.where(sink_id == r)[0]), 1
# Total expected number of transactions
yield assert_equal, len(trans_time), 7
# Check that at time step 1, there are 2 transactions
yield assert_equal, len(np.where(trans_time == 1)[0]), 2
# Check that at time step 2, there are 3 transactions
yield assert_equal, len(np.where(trans_time == 2)[0]), 3
# Check that at time step 3, there are 2 transactions
yield assert_equal, len(np.where(trans_time == 3)[0]), 2
# Check that at time step 1, there are 2 transactions with total
# amount of 2
quantity = 0
for t in np.where(trans_time == 1)[0]:
quantity += quantities[np.where(resource_ids == trans_resource[t])]
yield assert_equal, quantity, 2
# Check that at time step 2, there are 3 transactions with total
# amount of 3
quantity = 0
for t in np.where(trans_time == 2)[0]:
quantity += quantities[np.where(resource_ids == trans_resource[t])]
yield assert_equal, quantity, 3
# Check that at time step 3, there are 2 transactions with total
# amount of 2
quantity = 0
for t in np.where(trans_time == 3)[0]:
quantity += quantities[np.where(resource_ids == trans_resource[t])]
yield assert_equal, quantity, 2
output.close()
if os.path.isfile(tmp_file):
print("removing {0}".format(tmp_file))
os.remove(tmp_file)
