def all_prolif_qty(path, qty, eqn_type, file=None):
file_list = make_list(path)
qty_df = pd.DataFrame()
agent_df = pd.DataFrame()
for f in file_list:
db = cym.dbopen(f)
weapon_progress = cym.root_metric(name='WeaponProgress')
evaluator = cym.Evaluator(db)
frame = evaluator.eval('WeaponProgress',
conds=[('Decision', '==', 1),
('EqnType', '==', eqn_type)])
qty_df = pd.concat([qty_df, frame[:][qty]], ignore_index=True)
agent_entry = cym.root_metric(name='AgentEntry')
evaluator2 = cym.Evaluator(db)
agent_frame = evaluator2.eval('AgentEntry',
conds=[('Kind', '==', 'Inst')])
agent_df = pd.concat(
[agent_df, agent_frame[:][['AgentId', 'Prototype']]],
ignore_index=True)
if (file != None):
qty_df.to_csv(path + file, sep='\t')
agent_df.to_csv(path + 'agent_' + file, sep='\t')
return
else:
return qty_df
def test_timeseries_inventories_decayheat(db, fname, backend):
if not HAVE_PYNE:
raise SkipTest
evaler = cym.Evaluator(db)
cal = ts.inventories_decayheat(evaler)
exp_head = ['Time', 'DecayHeat']
assert_equal(list(cal), exp_head) # Check we have the correct headers
cal = ts.inventories_decayheat(evaler,
facilities=['Reactor1'],
nucs=['94239'])
refs = pd.DataFrame(
np.array([(0, 0.0), (1, 7.98590335085e+32), (2, 1.11634819022e+33),
(3, 1.43410604536e+33), (4, 9.53273565408e+32)],
dtype=ensure_dt_bytes([('Time', '<i8'),
('DecayHeat', '<f8')])))
assert_frame_equal(cal, refs)
cal = ts.inventories_decayheat(evaler,
facilities=['Reactor1'],
nucs=['94239', '92235'])
refs = pd.DataFrame(
np.array([(0, 0.0), (1, 7.98591200694e+32), (2, 1.11635390648e+33),
(3, 1.43411661226e+33), (4, 9.53310042276e+32)],
dtype=ensure_dt_bytes([('Time', '<i8'),
('DecayHeat', '<f8')])))
assert_frame_equal(cal, refs)
def test_timeseries_transactions(db, fname, backend):
evaler = cym.Evaluator(db)
cal = ts.transactions(evaler)
exp_head = ['Time', 'Mass']
assert_equal(list(cal), exp_head) # Check we have the correct headers
if not HAVE_PYNE:
raise SkipTest
# test single nuclide selection
cal = ts.transactions(evaler, nucs=['942390000'])
refs = pd.DataFrame(
np.array([
(0, 0.000000000),
(1, 0.0444814879803),
(2, 0.0889629759607),
(3, 0.0889629759607),
(4, 0.0889629759607),
],
dtype=ensure_dt_bytes([('Time', '<i8'), ('Mass', '<f8')])))
assert_frame_equal(cal, refs)
# test multiple nuclide selection
cal = ts.transactions(evaler, nucs=['942390000', '922380000'])
refs = pd.DataFrame(
np.array([
(0, 0.000000000),
(1, 0.831724864011),
(2, 1.66344972802),
(3, 2.62344972802),
(4, 2.62344972802),
],
dtype=ensure_dt_bytes([('Time', '<i8'), ('Mass', '<f8')])))
assert_frame_equal(cal, refs)
def test_timeseries_inventories(db, fname, backend):
evaler = cym.Evaluator(db)
cal = ts.inventories(evaler)
exp_head = ['Time', 'Quantity']
assert_equal(list(cal), exp_head) # Check we have the correct headers
if not HAVE_PYNE:
raise SkipTest
cal = ts.inventories(evaler, facilities=['Reactor1'], nucs=['94239'])
refs = pd.DataFrame(
np.array([(0, 0.0), (1, 0.0444814879803), (2, 0.0621806030246),
(3, 0.0798797180688), (4, 0.0530973451327)],
dtype=ensure_dt_bytes([('Time', '<i8'),
('Quantity', '<f8')])))
assert_frame_equal(cal, refs)
cal = ts.inventories(evaler,
facilities=['Reactor1'],
nucs=['94239', '92235'])
refs = pd.DataFrame(
np.array([(0, 0.0), (1, 0.0460607124057), (2, 0.0726093849721),
(3, 0.0991580575384), (4, 0.119646017699)],
dtype=ensure_dt_bytes([('Time', '<i8'),
('Quantity', '<f8')])))
assert_frame_equal(cal, refs)
def test_timeseries_inventories_activity(db, fname, backend):
if not HAVE_PYNE:
raise SkipTest
evaler = cym.Evaluator(db)
cal = ts.inventories_activity(evaler)
exp_head = ['Time', 'Activity']
assert_equal(list(cal), exp_head) # Check we have the correct headers
cal = ts.inventories_activity(evaler,
facilities=['Reactor1'],
nucs=['94239'])
refs = pd.DataFrame(
np.array([(0, 0.0), (1, 2.44036364223e+13), (2, 3.41138054869e+13),
(3, 4.38239745515e+13), (4, 2.91305071939e+13)],
dtype=ensure_dt_bytes([('Time', '<i8'),
('Activity', '<f8')])))
assert_frame_equal(cal, refs)
cal = ts.inventories_activity(evaler,
facilities=['Reactor1'],
nucs=['94239', '92235'])
refs = pd.DataFrame(
np.array([
(0, 0.0),
(1, 2.4403666094e+13),
(2, 3.41140014315e+13),
(3, 4.3824336769e+13),
(4, 2.91317575657e+13),
],
dtype=ensure_dt_bytes([('Time', '<i8'),
('Activity', '<f8')])))
assert_frame_equal(cal, refs)
def test_timeseries_transactions_decayheat(db, fname, backend):
if not HAVE_PYNE:
raise SkipTest
evaler = cym.Evaluator(db)
cal = ts.transactions_decayheat(evaler)
exp_head = ['Time', 'DecayHeat']
assert_equal(list(cal), exp_head) # Check we have the correct headers
# test single nuclide selection
cal = ts.transactions_decayheat(evaler, nucs=['942390000'])
refs = pd.DataFrame(
np.array([
(0, 0.000000000),
(1, 3.34065303191e+30),
(2, 6.68130606382e+30),
(3, 6.68130606382e+30),
(4, 6.68130606382e+30),
],
dtype=ensure_dt_bytes([('Time', '<i8'),
('DecayHeat', '<f8')])))
assert_frame_equal(cal, refs)
# test multiple nuclide selection
cal = ts.transactions_decayheat(evaler, nucs=['942390000', '922380000'])
refs = pd.DataFrame(
np.array([
(0, 0.000000000),
(1, 3.34091395721e+30),
(2, 6.68182791443e+30),
(3, 6.68214609848e+30),
(4, 6.68214609848e+30),
],
dtype=ensure_dt_bytes([('Time', '<i8'),
('DecayHeat', '<f8')])))
assert_frame_equal(cal, refs)
def test_timeseries_transactions_activity(db, fname, backend):
if not HAVE_PYNE:
raise SkipTest
evaler = cym.Evaluator(db)
cal = ts.transactions_activity(evaler)
exp_head = ['Time', 'Activity']
assert_equal(list(cal), exp_head) # Check we have the correct headers
# test single nuclide selection
cal = ts.transactions_activity(evaler, nucs=['942390000'])
refs = pd.DataFrame(
np.array([
(0, 0.000000000),
(1, 102084984531.0),
(2, 204169969062.0),
(3, 204169969062.0),
(4, 204169969062.0),
],
dtype=ensure_dt_bytes([('Time', '<i8'),
('Activity', '<f8')])))
assert_frame_equal(cal, refs)
# test multiple nuclide selection
cal = ts.transactions_activity(evaler, nucs=['942390000', '922380000'])
refs = pd.DataFrame(
np.array([
(0, 0.000000000),
(1, 102094774891.0),
(2, 204189549782.0),
(3, 204201488588.0),
(4, 204201488588.0),
],
dtype=ensure_dt_bytes([('Time', '<i8'),
('Activity', '<f8')])))
assert_frame_equal(cal, refs)
def objective(sim):
with cym.dbopen(sim) as db:
evaler = cym.Evaluator(db)
elec_gen = evaler.eval('FcoElectricityGenerated')
elec_gen = elec_gen[-200:]
demand = demand_curve(90, 0.01, 200)
score = sum((elec_gen.Power - demand).abs())
return score
def main():
global timestep
if len(sys.argv) != 3:
print("missing argument !!")
quit()
db = cym.dbopen(sys.argv[2])
ev = cym.Evaluator(db=db, write=False)
input_list = read_input(sys.argv[1])
process(ev, input_list)
def stock_analysis(filename):
"""Runs stock analysis utilities."""
global EVALER
for fig in FIGS:
fig.close()
FIGS.clear()
db = cym.dbopen(filename)
evaler = EVALER = cym.Evaluator(db)
plot_fco_egen()
#plot_fco_umined()
plot_builds()
def Trans(file, rec=(), send=(), nucs_=(), coms=()):
''' Return the transactions between senders (send) and receivers (rec),
filtered by nuclide (nucs) and commodities (coms)
'''
db = cym.dbopen(file)
ev = cym.Evaluator(db=db, write=False)
df1 = tm.transactions(ev,
receivers=rec,
senders=send,
nucs=nucs_,
commodities=coms)
return df1
def InvFrac(file, facility, nucs1=(), nucs2=(), factor1=1, factor2=1):
''' Return the fraction nucs1 / (nucs1+nucs2) the inventory of the
facilities (fac), weighting factor can be added on nucs1 and nucs2
'''
db = cym.dbopen(file)
ev = cym.Evaluator(db=db, write=False)
df1 = tm.inventories(ev, facilities=facility, nucs=nucs1)
df2 = tm.inventories(ev, facilities=facility, nucs=nucs2)
df_r = df2
df_r[df_r.columns[1]] = (df2[df2.columns[1]] / factor2) / \
(df1[df1.columns[1]] / factor1 + df2[df2.columns[1]] / factor2)
return df_r
def test_inventories(db, fname, backend):
evaler = cym.Evaluator(db)
cal = filters.inventories(evaler)
exp_head = ['SimId', 'AgentId', 'Prototype',
'Time', 'InventoryName', 'NucId', 'Quantity', 'Units']
assert_equal(list(cal), exp_head) # Check we have the correct headers
if not HAVE_PYNE:
raise SkipTest
cal = filters.inventories(evaler, facilities=['Reactor1'],
nucs=['94239'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
refs = pd.DataFrame(np.array([
(15, 'Reactor1', 1, 'core', 942390000, 0.0444814879803),
(15, 'Reactor1', 2, 'core', 942390000, 0.0444814879803),
(15, 'Reactor1', 2, 'spent', 942390000, 0.0176991150442),
(15, 'Reactor1', 3, 'core', 942390000, 0.0444814879803),
(15, 'Reactor1', 3, 'spent', 942390000, 0.0353982300885),
(15, 'Reactor1', 4, 'spent', 942390000, 0.0530973451327)
], dtype=ensure_dt_bytes([
('AgentId', '<i8'), ('Prototype', 'O'), ('Time', '<i8'),
('InventoryName', 'O'), ('NucId', '<i8'), ('Quantity', '<f8'),
('Units', '0')
]))
)
assert_frame_equal(cal, refs)
cal = filters.inventories(evaler, facilities=['Reactor1'],
nucs=['94239', '92235'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
refs = pd.DataFrame(np.array([
(15, 'Reactor1', 1, 'core', 922350000, 0.00157922442534),
(15, 'Reactor1', 1, 'core', 942390000, 0.0444814879803),
(15, 'Reactor1', 2, 'core', 922350000, 0.00157922442534),
(15, 'Reactor1', 2, 'core', 942390000, 0.0444814879803),
(15, 'Reactor1', 2, 'spent', 922350000, 0.00884955752212),
(15, 'Reactor1', 2, 'spent', 942390000, 0.0176991150442),
(15, 'Reactor1', 3, 'core', 922350000, 0.00157922442534),
(15, 'Reactor1', 3, 'core', 942390000, 0.0444814879803),
(15, 'Reactor1', 3, 'spent', 922350000, 0.0176991150442),
(15, 'Reactor1', 3, 'spent', 942390000, 0.0353982300885),
(15, 'Reactor1', 4, 'core', 922350000, 0.04),
(15, 'Reactor1', 4, 'spent', 922350000, 0.0265486725664),
(15, 'Reactor1', 4, 'spent', 942390000, 0.0530973451327)
], dtype=ensure_dt_bytes([
('AgentId', '<i8'), ('Prototype', 'O'), ('Time', '<i8'),
('InventoryName', 'O'), ('NucId', '<i8'), ('Quantity', '<f8'),
('Units', '0')
]))
)
assert_frame_equal(cal, refs)
def first_prolif_qty(path, qty, csv=None):
file_list = make_list(path)
qty_df = pd.DataFrame()
for f in file_list:
db = cym.dbopen(f)
weapon_progress = cym.root_metric(name='WeaponProgress')
evaluator = cym.Evaluator(db)
frame = evaluator.eval('WeaponProgress', conds=[('Decision', '==', 1)])
qty_df = pd.concat([qty_df, frame[:1][qty]], ignore_index=True)
if (csv != None):
qty_df.to_csv(path + csv, sep='\t')
return
else:
return qty_df
def idle_cap():
"""
This function uses cymetric to read the output_sqlite file for
total idle capacity value.
"""
f = open('output_name.txt', 'r')
if f.mode == 'r':
output_sqlite = f.read()
f.close()
ev = cym.Evaluator(db=cym.dbopen(output_sqlite), write=True)
val, val2, val3 = oup.idlecap(ev, '(60000+250*t/12.0)/1000.0')
f = open('idlecap.txt', 'w+')
f.write(str(val))
f.close()
return val
def dep_u():
"""
This function uses cymetric to read the output_sqlite file for
final depleted u value.
"""
f = open('output_name.txt', 'r')
if f.mode == 'r':
output_sqlite = f.read()
f.close()
ev = cym.Evaluator(db=cym.dbopen(output_sqlite), write=True)
val = cym.timeseries.transactions(ev,
commodities=['enrichmentwaste'])['Mass'].cumsum().iloc[-1]
print(val)
f = open('depu.txt', 'w+')
f.write(str(val))
f.close()
return val
def hlw():
"""
This function uses cymetric to read the output_sqlite file for
final hlw value.
"""
f = open('output_name.txt', 'r')
if f.mode == 'r':
output_sqlite = f.read()
f.close()
ev = cym.Evaluator(db=cym.dbopen(output_sqlite), write=True)
val = cym.timeseries.transactions(ev,
commodities=['lwrreprocessingwaste',
'moxreprocessingwaste',
'frreprocessingwaste'])[
'Mass'].cumsum().iloc[-1]
with open('hlw.txt', 'w') as f:
f.write(str(val))
return val
def fill_tree(parameter_list, file_list):
# Loop on Cyclus DB
global T, P, var
for file_name in file_list:
db = cym.dbopen(file_name)
evaler = cym.Evaluator(db=db, write=False)
# Reset Variables
reset_var()
T += evaler.eval('TimeList')['TimeStep'].tolist()
P += cytim.get_power(evaler)['Value'].tolist()
# Read variable
print(file_name)
for i, parameter in enumerate(parameter_list):
var[i].clear()
val = get_val(evaler, parameter)
var[i] += val
# Update Ttree
t.Fill()
# Close cyclus DB
db.close()
del evaler
def TransFrac(file='',
ev=None,
rec=(),
send=(),
nucs1=(),
nucs2=(),
factor1=1,
factor2=1):
''' Return the fraction nucs1 / (nucs1+nucs2) in the transaction between
senders and receivers, weighting factor can be added on nucs1 and nucs2
'''
if (file != ''):
db = cym.dbopen(file)
ev = cym.Evaluator(db=db, write=False)
elif (ev == None):
print('Need either a Filename or a cymetric evaler....')
return None
df1 = tm.transactions(ev, receivers=rec, senders=send, nucs=nucs1)
df2 = tm.transactions(ev, receivers=rec, senders=send, nucs=nucs2)
df_r = df2
df_r[df_r.columns[1]] = (df2[df2.columns[1]] / factor2) / \
(df1[df1.columns[1]] / factor1 + df2[df2.columns[1]] / factor2)
return df_r
def MakeFlowGraph(file, label=''):
''' Generate the transaction flow graph between facilities
'''
db_ = cym.dbopen(file)
ev_ = cym.Evaluator(db=db_, write=False)
return cgr.flow_graph(evaler=ev_, label=label)
def get_sqlite_evaluator():
outputfile = cymetric.dbopen(test_sqlite_path)
evaluate = cymetric.Evaluator(outputfile)
return evaluate
def test_transactions_nuc(db, fname, backend):
evaler = cym.Evaluator(db)
cal = filters.transactions_nuc(evaler)
exp_head = [
'SimId', 'ResourceId', 'NucId', 'Mass', 'ReceiverId',
'ReceiverPrototype', 'SenderId', 'SenderPrototype', 'TransactionId',
'Commodity', 'Time'
]
assert_equal(list(cal), exp_head) # Check we have the correct headers
if not HAVE_PYNE:
raise SkipTest
# test single nuclide selection
cal = filters.transactions_nuc(evaler, nucs=['942390000'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
# SimId change at each test need to drop it
cal = cal.drop('TransactionId', 1)
# SimId change at each test need to drop it
cal = cal.drop('ResourceId', 1)
refs = pd.DataFrame(
np.array([
(942390000, 0.0444814879803, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(942390000, 0.0444814879803, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(942390000, 0.0444814879803, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(942390000, 0.0444814879803, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(942390000, 0.0444814879803, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(942390000, 0.0444814879803, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(942390000, 0.0444814879803, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
],
dtype=ensure_dt_bytes([('NucId', '<i8'), ('Mass', '<f8'),
('ReceiverId', '<i8'),
('ReceiverPrototype', 'O'),
('SenderId', '<i8'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
# refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
# test multiple nuclide selection
cal = filters.transactions_nuc(evaler, nucs=['942390000', '922380000'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
# SimId change at each test need to drop it
cal = cal.drop('TransactionId', 1)
# SimId change at each test need to drop it
cal = cal.drop('ResourceId', 1)
refs = pd.DataFrame(
np.array([
(922380000, 0.7872433760310, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(942390000, 0.0444814879803, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(922380000, 0.7872433760310, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(942390000, 0.0444814879803, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(922380000, 0.7872433760310, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(942390000, 0.0444814879803, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(922380000, 0.7872433760310, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(942390000, 0.0444814879803, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(922380000, 0.7872433760310, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(942390000, 0.0444814879803, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(922380000, 0.7872433760310, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(942390000, 0.0444814879803, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(922380000, 0.7872433760310, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
(942390000, 0.0444814879803, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
(922380000, 0.9600000000000, 17, 'Reactor3', 13, 'UOX_Source',
'uox', 3),
(922380000, 0.9600000000000, 15, 'Reactor1', 13, 'UOX_Source',
'uox', 4),
],
dtype=ensure_dt_bytes([('NucId', '<i8'), ('Mass', '<f8'),
('ReceiverId', '<i8'),
('ReceiverPrototype', 'O'),
('SenderId', '<i8'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
# refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
#! /usr/bin/env python
import cymetric as cym
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
db = cym.dbopen('recycle.sqlite')
evaler = cym.Evaluator(db)
comm = evaler.eval('BuildSeries')
decomm = evaler.eval('DecommissionSeries')
# make exit counts negative for plotting purposes
neg = -decomm['Count']
decomm = decomm.drop('Count', axis=1)
decomm = pd.concat([decomm, neg], axis=1)
# for later merge, rename time columns
comm.rename(columns={'EnterTime': 'Time'}, inplace=True)
decomm.rename(columns={'ExitTime': 'Time'}, inplace=True)
# pivot tables for plotting purposes, and merge tables
c = comm.pivot('Time', 'Prototype')['Count'].reset_index()
d = decomm.pivot('Time', 'Prototype')['Count'].reset_index()
cd = pd.merge(c,
d,
left_on='Time',
right_on='Time',
how='outer',
sort=True,
suffixes=('_enter', '_exit')).fillna(0)
def get_table(db, table_name):
# Resources, Materials, Products, Recipes, Compostions, TimeSeriesEnrichmentFeed, TimeSeriesEnrichmentSWU, Transactions
evaler = cym.Evaluator(db)
return evaler.eval(table_name) # if attr is not None else
def test_inventories_decayheat(db, fname, backend):
if not HAVE_PYNE:
raise SkipTest
evaler = cym.Evaluator(db)
cal = filters.inventories_decayheat(evaler)
exp_head = [
'SimId', 'AgentId', 'Prototype', 'Time', 'InventoryName', 'NucId',
'Quantity', 'Activity', 'DecayHeat'
]
assert_equal(list(cal), exp_head) # Check we have the correct headers
cal = filters.inventories_decayheat(evaler,
facilities=['Reactor1'],
nucs=['94239'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
refs = pd.DataFrame(
np.array([(15, 'Reactor1', 1, 'core', 942390000, 0.0444814879803,
2.44036364223e+13, 7.98590335085e+32),
(15, 'Reactor1', 2, 'core', 942390000, 0.0444814879803,
2.44036364223e+13, 7.98590335085e+32),
(15, 'Reactor1', 2, 'spent', 942390000, 0.0176991150442,
9.71016906463e+12, 3.17757855136e+32),
(15, 'Reactor1', 3, 'core', 942390000, 0.0444814879803,
2.44036364223e+13, 7.98590335085e+32),
(15, 'Reactor1', 3, 'spent', 942390000, 0.0353982300885,
1.94203381293e+13, 6.35515710272e+32),
(15, 'Reactor1', 4, 'spent', 942390000, 0.0530973451327,
2.91305071939e+13, 9.53273565408e+32)],
dtype=ensure_dt_bytes([('AgentId', '<i8'), ('Prototype', 'O'),
('Time', '<i8'),
('InventoryName', 'O'),
('NucId', '<i8'), ('Quantity', '<f8'),
('Activity', '<f8'),
('DecayHeat', '<f8')])))
assert_frame_equal(cal, refs)
cal = filters.inventories_decayheat(evaler,
facilities=['Reactor1'],
nucs=['94239', '92235'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
refs = pd.DataFrame(
np.array([(15, 'Reactor1', 1, 'core', 922350000, 0.00157922442534,
29671782.9213, 8.65609466244e+26),
(15, 'Reactor1', 1, 'core', 942390000, 0.0444814879803,
2.44036364223e+13, 7.98590335085e+32),
(15, 'Reactor1', 2, 'core', 922350000, 0.00157922442534,
29671782.9213, 8.65609466244e+26),
(15, 'Reactor1', 2, 'core', 942390000, 0.0444814879803,
2.44036364223e+13, 7.98590335085e+32),
(15, 'Reactor1', 2, 'spent', 922350000, 0.00884955752212,
166272852.378, 4.85064734329e+27),
(15, 'Reactor1', 2, 'spent', 942390000, 0.0176991150442,
9.71016906463e+12, 3.17757855136e+32),
(15, 'Reactor1', 3, 'core', 922350000, 0.00157922442534,
29671782.9213, 8.65609466244e+26),
(15, 'Reactor1', 3, 'core', 942390000, 0.0444814879803,
2.44036364223e+13, 7.98590335085e+32),
(15, 'Reactor1', 3, 'spent', 922350000, 0.0176991150442,
332545704.756, 9.70129468658e+27),
(15, 'Reactor1', 3, 'spent', 942390000, 0.0353982300885,
1.94203381293e+13, 6.35515710272e+32),
(15, 'Reactor1', 4, 'core', 922350000, 0.04, 751553292.748,
2.19249259917e+28),
(15, 'Reactor1', 4, 'spent', 922350000, 0.0265486725664,
498818557.134, 1.45519420299e+28),
(15, 'Reactor1', 4, 'spent', 942390000, 0.0530973451327,
2.91305071939e+13, 9.53273565408e+32)],
dtype=ensure_dt_bytes([('AgentId', '<i8'), ('Prototype', 'O'),
('Time', '<i8'),
('InventoryName', 'O'),
('NucId', '<i8'), ('Quantity', '<f8'),
('Activity', '<f8'),
('DecayHeat', '<f8')])))
assert_frame_equal(cal, refs)
def test_transactions_decayheat(db, fname, backend):
if not HAVE_PYNE:
raise SkipTest
evaler = cym.Evaluator(db)
cal = filters.transactions_decayheat(evaler)
exp_head = [
'SimId', 'ResourceId', 'NucId', 'DecayHeat', 'ReceiverId',
'ReceiverPrototype', 'SenderId', 'SenderPrototype', 'TransactionId',
'Commodity', 'Time'
]
assert_equal(list(cal), exp_head) # Check we have the correct headers
# test single nuclide selection
cal = filters.transactions_decayheat(evaler, nucs=['942390000'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
# SimId change at each test need to drop it
cal = cal.drop('TransactionId', 1)
# SimId change at each test need to drop it
cal = cal.drop('ResourceId', 1)
refs = pd.DataFrame(
np.array([
(942390000, 3.34065303191e+30, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(942390000, 3.34065303191e+30, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(942390000, 3.34065303191e+30, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(942390000, 3.34065303191e+30, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(942390000, 3.34065303191e+30, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(942390000, 3.34065303191e+30, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(942390000, 3.34065303191e+30, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
],
dtype=ensure_dt_bytes([('NucId', '<i8'), ('DecayHeat', '<f8'),
('ReceiverId', '<i8'),
('ReceiverPrototype', 'O'),
('SenderId', '<i8'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
assert_frame_equal(cal, refs)
# test multiple nuclide selection
cal = filters.transactions_decayheat(evaler,
nucs=['942390000', '922380000'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
# SimId change at each test need to drop it
cal = cal.drop('TransactionId', 1)
# SimId change at each test need to drop it
cal = cal.drop('ResourceId', 1)
refs = pd.DataFrame(
np.array([
(922380000, 2.609253035160e26, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(942390000, 3.34065303191e+30, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(922380000, 2.609253035160e26, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(942390000, 3.34065303191e+30, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(922380000, 2.609253035160e26, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(942390000, 3.34065303191e+30, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(922380000, 2.609253035160e26, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(942390000, 3.34065303191e+30, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(922380000, 2.609253035160e26, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(942390000, 3.34065303191e+30, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(922380000, 2.609253035160e26, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(942390000, 3.34065303191e+30, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(922380000, 2.609253035160e26, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
(942390000, 3.34065303191e+30, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
(922380000, 3.18184057182e+26, 17, 'Reactor3', 13, 'UOX_Source',
'uox', 3),
(922380000, 3.18184057182e+26, 15, 'Reactor1', 13, 'UOX_Source',
'uox', 4),
],
dtype=ensure_dt_bytes([('NucId', '<i8'), ('DecayHeat', '<f8'),
('ReceiverId', '<i8'),
('ReceiverPrototype', 'O'),
('SenderId', '<i8'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
assert_frame_equal(cal, refs)
def test_transactions(db, fname, backend):
evaler = cym.Evaluator(db)
cal = filters.transactions(evaler)
exp_head = [
'SimId', 'ReceiverId', 'ReceiverPrototype', 'SenderId',
'SenderPrototype', 'TransactionId', 'ResourceId', 'Commodity', 'Time'
]
assert_equal(list(cal), exp_head) # Check we have the correct headers
# SimId et al. change at each test need to drop it
drop_cols = [
'SimId', 'TransactionId', 'ResourceId', 'ReceiverId', 'SenderId'
]
cal = cal.drop(drop_cols, axis=1)
refs = pd.DataFrame(
np.array([
('Reactor1', 'UOX_Source', 'uox', 4),
('Reactor1', 'MOX_Source', 'mox', 1),
('Reactor1', 'MOX_Source', 'mox', 2),
('Reactor1', 'MOX_Source', 'mox', 3),
('Reactor2', 'MOX_Source', 'mox', 2),
('Reactor2', 'MOX_Source', 'mox', 3),
('Reactor2', 'MOX_Source', 'mox', 4),
('Reactor3', 'UOX_Source', 'uox', 3),
('Reactor3', 'MOX_Source', 'mox', 4),
],
dtype=ensure_dt_bytes([('ReceiverPrototype', 'O'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
# test single sender
cal = filters.transactions(evaler, senders=['UOX_Source'])
cal = cal.drop(drop_cols, axis=1)
refs = pd.DataFrame(
np.array([
('Reactor1', 'UOX_Source', 'uox', 4),
('Reactor3', 'UOX_Source', 'uox', 3),
],
dtype=ensure_dt_bytes([('ReceiverPrototype', 'O'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
# test multiple sender
cal = filters.transactions(evaler, senders=['UOX_Source', 'MOX_Source'])
cal = cal.drop(drop_cols, axis=1)
refs = pd.DataFrame(
np.array([
('Reactor1', 'UOX_Source', 'uox', 4),
('Reactor1', 'MOX_Source', 'mox', 1),
('Reactor1', 'MOX_Source', 'mox', 2),
('Reactor1', 'MOX_Source', 'mox', 3),
('Reactor2', 'MOX_Source', 'mox', 2),
('Reactor2', 'MOX_Source', 'mox', 3),
('Reactor2', 'MOX_Source', 'mox', 4),
('Reactor3', 'UOX_Source', 'uox', 3),
('Reactor3', 'MOX_Source', 'mox', 4),
],
dtype=ensure_dt_bytes([('ReceiverPrototype', 'O'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
# test single receiver
cal = filters.transactions(evaler, receivers=['Reactor1'])
cal = cal.drop(drop_cols, 1) # SimId change at each test need to drop it
refs = pd.DataFrame(
np.array([
('Reactor1', 'UOX_Source', 'uox', 4),
('Reactor1', 'MOX_Source', 'mox', 1),
('Reactor1', 'MOX_Source', 'mox', 2),
('Reactor1', 'MOX_Source', 'mox', 3),
],
dtype=ensure_dt_bytes([('ReceiverPrototype', 'O'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
# test multiple sender
cal = filters.transactions(evaler, receivers=['Reactor1', 'Reactor3'])
cal = cal.drop(drop_cols, 1) # SimId change at each test need to drop it
refs = pd.DataFrame(
np.array([
('Reactor1', 'UOX_Source', 'uox', 4),
('Reactor1', 'MOX_Source', 'mox', 1),
('Reactor1', 'MOX_Source', 'mox', 2),
('Reactor1', 'MOX_Source', 'mox', 3),
('Reactor3', 'UOX_Source', 'uox', 3),
('Reactor3', 'MOX_Source', 'mox', 4),
],
dtype=ensure_dt_bytes([('ReceiverPrototype', 'O'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
# test multiple sender and multiple receiver
cal = filters.transactions(evaler,
senders=['UOX_Source', 'MOX_Source'],
receivers=['Reactor1', 'Reactor2'])
cal = cal.drop(drop_cols, 1) # SimId change at each test need to drop it
refs = pd.DataFrame(
np.array([
('Reactor1', 'UOX_Source', 'uox', 4),
('Reactor1', 'MOX_Source', 'mox', 1),
('Reactor1', 'MOX_Source', 'mox', 2),
('Reactor1', 'MOX_Source', 'mox', 3),
('Reactor2', 'MOX_Source', 'mox', 2),
('Reactor2', 'MOX_Source', 'mox', 3),
('Reactor2', 'MOX_Source', 'mox', 4),
],
dtype=ensure_dt_bytes([('ReceiverPrototype', 'O'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
# test single filters.odity
cal = filters.transactions(evaler, commodities=['uox'])
cal = cal.drop(drop_cols, 1) # SimId change at each test need to drop it
refs = pd.DataFrame(
np.array([
('Reactor1', 'UOX_Source', 'uox', 4),
('Reactor3', 'UOX_Source', 'uox', 3),
],
dtype=ensure_dt_bytes([('ReceiverPrototype', 'O'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
# test multiple sender
cal = filters.transactions(evaler, commodities=['uox', 'mox'])
cal = cal.drop(drop_cols, 1) # SimId change at each test need to drop it
refs = pd.DataFrame(
np.array([
('Reactor1', 'UOX_Source', 'uox', 4),
('Reactor1', 'MOX_Source', 'mox', 1),
('Reactor1', 'MOX_Source', 'mox', 2),
('Reactor1', 'MOX_Source', 'mox', 3),
('Reactor2', 'MOX_Source', 'mox', 2),
('Reactor2', 'MOX_Source', 'mox', 3),
('Reactor2', 'MOX_Source', 'mox', 4),
('Reactor3', 'UOX_Source', 'uox', 3),
('Reactor3', 'MOX_Source', 'mox', 4),
],
dtype=ensure_dt_bytes([('ReceiverPrototype', 'O'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
refs.index = refs.index.astype('str')
assert_frame_equal(cal, refs)
def test_transactions_activity(db, fname, backend):
if not HAVE_PYNE:
raise SkipTest
evaler = cym.Evaluator(db)
cal = filters.transactions_activity(evaler)
exp_head = [
'SimId', 'ResourceId', 'NucId', 'Activity', 'ReceiverId',
'ReceiverPrototype', 'SenderId', 'SenderPrototype', 'TransactionId',
'Commodity', 'Time'
]
assert_equal(list(cal), exp_head) # Check we have the correct headers
# test single nuclide selection
cal = filters.transactions_activity(evaler, nucs=['942390000'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
# SimId change at each test need to drop it
cal = cal.drop('TransactionId', 1)
# SimId change at each test need to drop it
cal = cal.drop('ResourceId', 1)
refs = pd.DataFrame(
np.array([
(942390000, 102084984531.0, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(942390000, 102084984531.0, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(942390000, 102084984531.0, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(942390000, 102084984531.0, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(942390000, 102084984531.0, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(942390000, 102084984531.0, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(942390000, 102084984531.0, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
],
dtype=ensure_dt_bytes([('NucId', '<i8'), ('Activity', '<f8'),
('ReceiverId', '<i8'),
('ReceiverPrototype', 'O'),
('SenderId', '<i8'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
assert_frame_equal(cal, refs)
# test multiple nuclide selection
cal = filters.transactions_activity(evaler,
nucs=['942390000', '922380000'])
cal = cal.drop('SimId', 1) # SimId change at each test need to drop it
# SimId change at each test need to drop it
cal = cal.drop('TransactionId', 1)
# SimId change at each test need to drop it
cal = cal.drop('ResourceId', 1)
refs = pd.DataFrame(
np.array([
(922380000, 9790360.331530, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(942390000, 102084984531.0, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 1),
(922380000, 9790360.331530, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(942390000, 102084984531.0, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 2),
(922380000, 9790360.331530, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(942390000, 102084984531.0, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 2),
(922380000, 9790360.331530, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(942390000, 102084984531.0, 15, 'Reactor1', 14, 'MOX_Source',
'mox', 3),
(922380000, 9790360.331530, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(942390000, 102084984531.0, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 3),
(922380000, 9790360.331530, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(942390000, 102084984531.0, 16, 'Reactor2', 14, 'MOX_Source',
'mox', 4),
(922380000, 9790360.331530, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
(942390000, 102084984531.0, 17, 'Reactor3', 14, 'MOX_Source',
'mox', 4),
(922380000, 11938805.97080, 17, 'Reactor3', 13, 'UOX_Source',
'uox', 3),
(922380000, 11938805.97080, 15, 'Reactor1', 13, 'UOX_Source',
'uox', 4),
],
dtype=ensure_dt_bytes([('NucId', '<i8'), ('Activity', '<f8'),
('ReceiverId', '<i8'),
('ReceiverPrototype', 'O'),
('SenderId', '<i8'),
('SenderPrototype', 'O'),
('Commodity', 'O'), ('Time', '<i8')])))
assert_frame_equal(cal, refs)
