class Sink(Facility):
"""This sink facility accepts specified amount of commodity."""
in_commods = ts.VectorString(
doc="commodities that the sink facility accepts.",
tooltip="input commodities for the sink",
uilabel="List of Input Commodities",
uitype=["oneormore", "incommodity"],
)
recipe = ts.String(
tooltip="input/request recipe name",
doc="Name of recipe to request. If empty, sink requests material no "
"particular composition.",
default="",
uilabel="Input Recipe",
uitype="recipe",
)
max_inv_size = ts.Double(
default=1e299,
doc="total maximum inventory size of sink facility",
uilabel="Maximum Inventory",
tooltip="sink maximum inventory size",
)
capacity = ts.Double(
doc="capacity the sink facility can accept at each time step",
uilabel="Maximum Throughput",
tooltip="sink capacity",
default=100.0,
)
inventory = ts.ResourceBuffInv(capacity='max_inv_size')
def get_material_requests(self):
if len(self.recipe) == 0:
comp = {}
else:
comp = self.context.get_recipe(self.recipe)
mat = ts.Material.create_untracked(self.capacity, comp)
port = {
"commodities": {c: mat
for c in self.in_commods},
"constraints": self.capacity
}
return port
def get_product_requests(self):
prod = ts.Product.create_untracked(self.capacity, "")
port = {
"commodities": {c: prod
for c in self.in_commods},
"constraints": self.capacity
}
return port
def accept_material_trades(self, responses):
for mat in responses.values():
self.inventory.push(mat)
def accept_product_trades(self, responses):
for prod in responses.values():
self.inventory.push(prod)
class TimeSeriesInst(Institution):
"""
This institution deploys facilities based on demand curves using
time series methods.
"""
commodities = ts.VectorString(
doc="A list of commodities that the institution will manage. " +
"commodity_prototype_capacity format" +
" where the commoditity is what the facility supplies",
tooltip="List of commodities in the institution.",
uilabel="Commodities",
uitype="oneOrMore")
demand_eq = ts.String(
doc=
"This is the string for the demand equation of the driving commodity. "
+ "The equation should use `t' as the dependent variable",
tooltip="Demand equation for driving commodity",
uilabel="Demand Equation")
calc_method = ts.String(
doc=
"This is the calculated method used to determine the supply and demand "
+
"for the commodities of this institution. Currently this can be ma for "
+ "moving average, or arma for autoregressive moving average.",
tooltip="Calculation method used to predict supply/demand",
uilabel="Calculation Method")
record = ts.Bool(
doc=
"Indicates whether or not the institution should record it's output to text "
+
"file outputs. The output files match the name of the demand commodity of the "
+ "institution.",
tooltip=
"Boolean to indicate whether or not to record output to text file.",
uilabel="Record to Text",
default=False)
driving_commod = ts.String(
doc="Sets the driving commodity for the institution. That is the " +
"commodity that no_inst will deploy against the demand equation.",
tooltip="Driving Commodity",
uilabel="Driving Commodity",
default="POWER")
steps = ts.Int(
doc="The number of timesteps forward to predict supply and demand",
tooltip="The number of predicted steps forward",
uilabel="Timesteps for Prediction",
default=1)
back_steps = ts.Int(
doc="This is the number of steps backwards from the current time step"
+ "that will be used to make the prediction. If this is set to '0'" +
"then the calculation will use all values in the time series.",
tooltip="",
uilabel="Back Steps",
default=10)
supply_std_dev = ts.Double(
doc="The standard deviation adjustment for the supple side.",
tooltip="The standard deviation adjustment for the supple side.",
uilabel="Supply Std Dev",
default=0)
demand_std_dev = ts.Double(
doc="The standard deviation adjustment for the demand side.",
tooltip="The standard deviation adjustment for the demand side.",
uilabel="Demand Std Dev",
default=0)
demand_std_dev = ts.Double(
doc="The standard deviation adjustment for the demand side.",
tooltip="The standard deviation adjustment for the demand side.",
uilabel="Demand Std Dev",
default=0)
degree = ts.Int(
doc="The degree of the fitting polynomial.",
tooltip="The degree of the fitting polynomial, if using calc methods" +
" poly, fft, holtz-winter and exponential smoothing." +
" Additionally, degree is used to as the 'period' input to " +
"the stepwise_seasonal method.",
uilabel="Degree Polynomial Fit / Period for stepwise_seasonal",
default=1)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.commodity_supply = {}
self.commodity_demand = {}
self.rev_commodity_supply = {}
self.rev_commodity_demand = {}
self.fresh = True
CALC_METHODS['ma'] = no.predict_ma
CALC_METHODS['arma'] = no.predict_arma
CALC_METHODS['arch'] = no.predict_arch
CALC_METHODS['poly'] = do.polyfit_regression
CALC_METHODS['exp_smoothing'] = do.exp_smoothing
CALC_METHODS['holt_winters'] = do.holt_winters
CALC_METHODS['fft'] = do.fft
CALC_METHODS['sw_seasonal'] = ml.stepwise_seasonal
def print_variables(self):
print('commodities: %s' % self.commodity_dict)
print('demand_eq: %s' % self.demand_eq)
print('calc_method: %s' % self.calc_method)
print('record: %s' % str(self.record))
print('steps: %i' % self.steps)
print('back_steps: %i' % self.back_steps)
print('supply_std_dev: %f' % self.supply_std_dev)
print('demand_std_dev: %f' % self.demand_std_dev)
def parse_commodities(self, commodities):
""" This function parses the vector of strings commodity variable
and replaces the variable as a dictionary. This function should be deleted
after the map connection is fixed."""
temp = commodities
commodity_dict = {}
for entry in temp:
# commodity, prototype, capacity, preference, constraint_commod, constraint
z = entry.split('_')
if len(z) < 3:
raise ValueError(
'Input is malformed: need at least commodity_prototype_capacity'
)
else:
# append zero for all other values if not defined
while len(z) < 6:
z.append(0)
if z[0] not in commodity_dict.keys():
commodity_dict[z[0]] = {}
commodity_dict[z[0]].update({
z[1]: {
'cap': float(z[2]),
'pref': str(z[3]),
'constraint_commod': str(z[4]),
'constraint': float(z[5])
}
})
else:
commodity_dict[z[0]].update({
z[1]: {
'cap': float(z[2]),
'pref': str(z[3]),
'constraint_commod': str(z[4]),
'constraint': float(z[5])
}
})
return commodity_dict
def enter_notify(self):
super().enter_notify()
if self.fresh:
# convert list of strings to dictionary
self.commodity_dict = self.parse_commodities(self.commodities)
commod_list = list(self.commodity_dict.keys())
for key, val in self.commodity_dict.items():
for key2, val2 in val.items():
if val2['constraint_commod'] != '0':
commod_list.append(val2['constraint_commod'])
commod_list = list(set(commod_list))
for commod in commod_list:
lib.TIME_SERIES_LISTENERS["supply" + commod].append(
self.extract_supply)
lib.TIME_SERIES_LISTENERS["demand" + commod].append(
self.extract_demand)
self.commodity_supply[commod] = defaultdict(float)
self.commodity_demand[commod] = defaultdict(float)
self.fresh = False
def decision(self):
"""
This is the tock method for decision the institution. Here the institution determines the difference
in supply and demand and makes the the decision to deploy facilities or not.
"""
time = self.context.time
for commod, proto_dict in self.commodity_dict.items():
diff, supply, demand = self.calc_diff(commod, time)
lib.record_time_series('calc_supply' + commod, self, supply)
lib.record_time_series('calc_demand' + commod, self, demand)
if diff < 0:
deploy_dict = solver.deploy_solver(self.commodity_supply,
self.commodity_dict, commod,
diff, time)
for proto, num in deploy_dict.items():
for i in range(num):
self.context.schedule_build(self, proto)
if self.record:
out_text = "Time " + str(time) + \
" Deployed " + str(len(self.children))
out_text += " supply " + \
str(self.commodity_supply[commod][time])
out_text += " demand " + \
str(self.commodity_demand[commod][time]) + "\n"
with open(commod + ".txt", 'a') as f:
f.write(out_text)
def calc_diff(self, commod, time):
"""
This function calculates the different in supply and demand for a given facility
Parameters
----------
time : int
This is the time step that the difference is being calculated for.
Returns
-------
diff : double
This is the difference between supply and demand at [time]
supply : double
The calculated supply of the supply commodity at [time].
demand : double
The calculated demand of the demand commodity at [time]
"""
if time not in self.commodity_demand[commod]:
t = 0
self.commodity_demand[commod][time] = eval(self.demand_eq)
if time not in self.commodity_supply[commod]:
self.commodity_supply[commod][time] = 0.0
supply = self.predict_supply(commod)
demand = self.predict_demand(commod, time)
diff = supply - demand
return diff, supply, demand
def predict_supply(self, commod):
if self.calc_method in ['arma', 'ma', 'arch']:
supply = CALC_METHODS[self.calc_method](
self.commodity_supply[commod],
steps=self.steps,
std_dev=self.supply_std_dev,
back_steps=self.back_steps)
elif self.calc_method in [
'poly', 'exp_smoothing', 'holt_winters', 'fft'
]:
supply = CALC_METHODS[self.calc_method](
self.commodity_supply[commod],
back_steps=self.back_steps,
degree=self.degree)
elif self.calc_method in ['sw_seasonal']:
supply = CALC_METHODS[self.calc_method](
self.commodity_supply[commod], period=self.degree)
else:
raise ValueError(
'The input calc_method is not valid. Check again.')
return supply
def predict_demand(self, commod, time):
if commod == self.driving_commod:
demand = self.demand_calc(time + 1)
self.commodity_demand[commod][time + 1] = demand
else:
if self.calc_method in ['arma', 'ma', 'arch']:
demand = CALC_METHODS[self.calc_method](
self.commodity_demand[commod],
steps=self.steps,
std_dev=self.supply_std_dev,
back_steps=self.back_steps)
elif self.calc_method in [
'poly', 'exp_smoothing', 'holt_winters', 'fft'
]:
demand = CALC_METHODS[self.calc_method](
self.commodity_demand[commod],
back_steps=self.back_steps,
degree=self.degree)
elif self.calc_method in ['sw_seasonal']:
demand = CALC_METHODS[self.calc_method](
self.commodity_demand[commod], period=self.degree)
else:
raise ValueError(
'The input calc_method is not valid. Check again.')
return demand
def extract_supply(self, agent, time, value, commod):
"""
Gather information on the available supply of a commodity over the
lifetime of the simulation.
Parameters
----------
agent : cyclus agent
This is the agent that is making the call to the listener.
time : int
Timestep that the call is made.
value : object
This is the value of the object being recorded in the time
series.
"""
commod = commod[6:]
self.commodity_supply[commod][time] += value
# update commodities
# self.commodity_dict[commod] = {agent.prototype: value}
def extract_demand(self, agent, time, value, commod):
"""
Gather information on the demand of a commodity over the
lifetime of the simulation.
Parameters
----------
agent : cyclus agent
This is the agent that is making the call to the listener.
time : int
Timestep that the call is made.
value : object
This is the value of the object being recorded in the time
series.
"""
commod = commod[6:]
self.commodity_demand[commod][time] += value
def demand_calc(self, time):
"""
Calculate the electrical demand at a given timestep (time).
Parameters
----------
time : int
The timestep that the demand will be calculated at.
Returns
-------
demand : The calculated demand at a given timestep.
"""
t = time
demand = eval(self.demand_eq)
return demand
class NOInst(Institution):
"""
This institution deploys facilities based on demand curves using
Non Optimizing (NO) methods.
"""
prototypes = ts.VectorString(
doc="A list of prototypes that the institution will draw upon to fit" +
"the demand curve",
tooltip="List of prototypes the institution can use to meet demand",
uilabel="Prototypes",
uitype="oneOrMore")
growth_rate = ts.Double(
doc="This value represents the growth rate that the institution is " +
"attempting to meet.",
tooltip="Growth rate of growth commodity",
uilabel="Growth Rate",
default="0.02")
supply_commod = ts.String(
doc=
"The commodity this institution will be monitoring for supply growth.",
tooltip="Supply commodity",
uilabel="Supply Commodity")
demand_commod = ts.String(
doc=
"The commodity this institution will be monitoring for demand growth.",
tooltip="Growth commodity",
uilabel="Growth Commodity")
initial_demand = ts.Double(doc="The initial power of the facility",
tooltip="Initital demand",
uilabel="Initial demand")
calc_method = ts.String(
doc=
"This is the calculated method used to determine the supply and demand "
+
"for the commodities of this institution. Currently this can be ma for "
+ "moving average, or arma for autoregressive moving average.",
tooltip="Calculation method used to predict supply/demand",
uilabel="Calculation Method")
record = ts.Bool(
doc=
"Indicates whether or not the institution should record it's output to text "
+
"file outputs. The output files match the name of the demand commodity of the "
+ "institution.",
tooltip=
"Boolean to indicate whether or not to record output to text file.",
uilabel="Record to Text",
default=False)
supply_std_dev = ts.Double(
doc="The number of standard deviations off mean for ARMA predictions",
tooltip="Std Dev off mean for ARMA",
uilabel="Supple Std Dev",
default=0.)
demand_std_dev = ts.Double(
doc="The number of standard deviations off mean for ARMA predictions",
tooltip="Std Dev off mean for ARMA",
uilabel="Demand Std Dev",
default=0.)
steps = ts.Int(
doc="The number of timesteps forward for ARMA or order of the MA",
tooltip="Std Dev off mean for ARMA",
uilabel="Demand Std Dev",
default=1)
back_steps = ts.Int(
doc="This is the number of steps backwards from the current time step"
+ "that will be used to make the prediction. If this is set to '0'" +
"then the calculation will use all values in the time series.",
tooltip="",
uilabel="",
default="5")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.commodity_supply = defaultdict(float)
self.commodity_demand = defaultdict(float)
self.fac_supply = {}
CALC_METHODS['ma'] = self.moving_avg
CALC_METHODS['arma'] = self.predict_arma
CALC_METHODS['arch'] = self.predict_arch
def enter_notify(self):
super().enter_notify()
lib.TIME_SERIES_LISTENERS[self.supply_commod].append(
self.extract_supply)
lib.TIME_SERIES_LISTENERS[self.demand_commod].append(
self.extract_demand)
def tock(self):
"""
This is the tock method for the institution. Here the institution determines the difference
in supply and demand and makes the the decision to deploy facilities or not.
"""
time = self.context.time
diff, supply, demand = self.calc_diff(time)
if diff < 0:
proto = random.choice(self.prototypes)
prod_rate = self.commodity_supply[time] / len(self.children)
number = np.ceil(-1 * diff / prod_rate)
i = 0
while i < number:
self.context.schedule_build(self, proto)
i += 1
if self.record:
with open(self.demand_commod + ".txt", 'a') as f:
f.write("Time " + str(time) + " Deployed " +
str(len(self.children)) + " supply " +
str(self.commodity_supply[time]) + " demand " +
str(self.commodity_demand[time]) + "\n")
def calc_diff(self, time):
"""
This function calculates the different in supply and demand for a given facility
Parameters
----------
time : int
This is the time step that the difference is being calculated for.
Returns
-------
diff : double
This is the difference between supply and demand at [time]
supply : double
The calculated supply of the supply commodity at [time].
demand : double
The calculated demand of the demand commodity at [time]
"""
try:
supply = CALC_METHODS[self.calc_method](
self.commodity_supply,
steps=self.steps,
std_dev=self.supply_std_dev)
except (ValueError, np.linalg.linalg.LinAlgError):
supply = CALC_METHODS['ma'](self.commodity_supply)
if not self.commodity_demand:
self.commodity_demand[time] = self.initial_demand
if self.demand_commod == 'power':
demand = self.demand_calc(time + 1)
self.commodity_demand[time] = demand
try:
demand = CALC_METHODS[self.calc_method](
self.commodity_demand,
steps=self.steps,
std_dev=self.demand_std_dev)
except (np.linalg.linalg.LinAlgError, ValueError):
demand = CALC_METHODS['ma'](self.commodity_demand)
diff = supply - demand
return diff, supply, demand
def extract_supply(self, agent, time, value):
"""
Gather information on the available supply of a commodity over the
lifetime of the simulation.
Parameters
----------
agent : cyclus agent
This is the agent that is making the call to the listener.
time : int
Timestep that the call is made.
value : object
This is the value of the object being recorded in the time
series.
"""
self.commodity_supply[time] += value
def extract_demand(self, agent, time, value):
"""
Gather information on the demand of a commodity over the
lifetime of the simulation.
Parameters
----------
agent : cyclus agent
This is the agent that is making the call to the listener.
time : int
Timestep that the call is made.
value : object
This is the value of the object being recorded in the time
series.
"""
self.commodity_demand[time] += value
def demand_calc(self, time):
"""
Calculate the electrical demand at a given timestep (time).
Parameters
----------
time : int
The timestep that the demand will be calculated at.
Returns
-------
demand : The calculated demand at a given timestep.
"""
timestep = self.context.dt
time = time * timestep
demand = self.initial_demand * (
(1.0 + self.growth_rate)**(time / 3.154e+7))
return demand
def moving_avg(self, ts, steps=1, std_dev=0, back_steps=5):
"""
Calculates the moving average of a previous [order] entries in
timeseries [ts]. It will automatically reduce the order if the
length of ts is shorter than the order.
Parameters:
-----------
ts : Array of doubles
An array of time series data to be used for the arma prediction
order : int
The number of values used for the moving average.
Returns
-------
x : The moving average calculated by the function.
"""
supply = np.array(list(ts.values()))
if steps >= len(supply):
steps = len(supply) * -1
else:
steps *= -1
x = np.average(supply[steps:])
return x
def predict_arma(self, ts, steps=1, std_dev=0, back_steps=5):
"""
Predict the value of supply or demand at a given time step using the
currently available time series data. This method impliments an ARMA
calculation to perform the prediciton.
Parameters:
-----------
ts : Array of doubles
An array of time series data to be used for the arma prediction
time: int
The number of timesteps to predict forward.
Returns:
--------
x : Predicted value for the time series at chosen timestep (time).
"""
v = list(ts.values())
fit = sm.tsa.ARMA(v, (1, 0)).fit(disp=-1)
forecast = fit.forecast(steps)
x = fit[0][steps - 1] + fit[1][steps - 1] * std_dev
return x
def predict_arch(self, ts, steps=1, std_dev=0, back_steps=5):
"""
Predict the value of supply or demand at a given time step using the
currently available time series data. This method impliments an ARCH
calculation to perform the prediciton.
"""
f_obs = len(ts) - back_steps
if f_obs < 0 or back_steps == 0: f_obs = 0
model = arch_model(ts)
fit = model.fit(disp='nothing',
update_freq=0,
show_warning=False,
first_obs=f_obs)
forecast = fit.forecast(horizon=steps)
x = forecast.mean.get('h.1')[len(ts) - 1]
std_dev = math.sqrt(
forecast.variance.get('h.1')[len(ts) - 1]) * std_dev
return x + std_dev
class ann_lwr(Facility):
fuel_incommod = ts.String(
doc="The commodity name for incoming fuel",
tooltip="Incoming fuel",
uilabel="Incoming fuel"
)
fuel_outcommod = ts.String(
doc="The commodity name for discharge fuel",
tooltip="Discharge Fuel",
uilabel="Discharge Fuel"
)
pickle_path = ts.String(
doc="Path to the pickle file",
tooltip="Absolute path to the pickle file"
)
# one row would be 2.1_30000 3.1_40000 4.1_50000 etc
enr_bu_matrix = ts.VectorString(
doc="enrichment and burnup matrix",
tooltip="enrichment_burnup column separated by space"
)
n_assem_core = ts.Int(
doc="Number of assemblies",
tooltip="Number of assemblies in core"
)
n_assem_batch = ts.Int(
doc="Number of assemblies per batch",
tooltip="Number of assemblies per batch"
)
assem_size = ts.Double(
doc="Assembly mass",
tooltip="Assembly mass"
)
power_cap = ts.Double(
doc="Power capacity of reactor",
tooltip="Power capacity of reactor",
)
cycle_time_eq = ts.String(
doc="cycle time of reactor equation",
tooltip="Cycle time of reactor equation"
)
refuel_time_eq = ts.String(
doc="Refuel time of reactor equation",
tooltip="Refuel time of reactor equation"
)
core = ts.ResBufMaterialInv()
waste = ts.ResBufMaterialInv()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def enter_notify(self):
super().enter_notify()
self.model_dict = pickle.load(open(self.pickle_path, 'rb'))
# change other to h-1
other_index = self.model_dict['iso_list'].index('other')
self.model_dict['iso_list'][other_index] = 'h-1'
self.iso_list = self.model_dict['iso_list']
# check if it's integer batches
if (self.n_assem_core / self.n_assem_batch)%1 != 0:
raise ValueError('Sorry can only do integer batches')
# input consistency checking
self.enr_matrix, self.bu_matrix = self.check_enr_bu_matrix()
# !!
self.f = open('f.txt', 'w')
# set initial cycle and refuel time
t = self.context.time
self.cycle_time = max(0, int(eval(self.cycle_time_eq)))
self.refuel_time = max(0, int(eval(self.refuel_time_eq)))
# set core capacity
self.core.capacity = self.n_assem_core * self.assem_size
self.cycle_step = 0
self.batch_gen = 0
self.n_batch = int(self.n_assem_core / self.n_assem_batch)
# if no exit time, exit time is 1e5
if self.exit_time == -1:
self.decom_time = 1e5
else:
self.decom_time = self.exit_time
def tick(self):
# If time to decommission, where if decommissioning
# mid cycle, deplete using weighted average
# and discharge
if self.context.time == self.decom_time:
# burnup is prorated by the ratio
cycle_step_ratio = self.cycle_step / self.cycle_time
for index, bu_list in enumerate(self.bu_matrix):
prorated_bu_list = bu_list * cycle_step_ratio
self.transmute_and_discharge(prorated_bu_list,
self.enr_matrix[index])
return
if self.cycle_step == self.cycle_time:
if self.batch_gen < self.n_batch:
i = self.batch_gen
else:
i = -1
bu_list = self.bu_matrix[i]
self.transmute_and_discharge(bu_list,
self.enr_matrix[i])
self.batch_gen += 1
def tock(self):
if (self.cycle_step >= self.cycle_time + self.refuel_time) and (self.is_core_full()):
t = self.context.time
self.cycle_time = max(0, int(eval(self.cycle_time_eq)))
self.refuel_time = max(0, int(eval(self.refuel_time_eq)))
self.cycle_step = 1
# produce power if core is full
if (self.cycle_step >= 0) and (self.cycle_step < self.cycle_time) and (self.is_core_full()):
self.produce_power(True)
else:
self.produce_power(False)
if self.cycle_step > 0 or self.is_core_full():
self.cycle_step += 1
def get_material_bids(self, requests):
""" Gets material bids that want its 'outcommod' and
returns bid portfolio
"""
bids = []
if self.fuel_outcommod in requests.keys():
reqs = requests[self.fuel_outcommod]
for req in reqs:
if self.waste.empty():
break
qty = min(req.target.quantity, self.waste.quantity
)
next_in_line = self.waste.peek()
mat = ts.Material.create_untracked(qty, next_in_line.comp())
bids.append({'request': req, 'offer': mat})
if len(bids) == 0:
return
port = {'bids': bids}
return port
def get_material_trades(self, trades):
""" Give out fuel_outcommod from waste buffer"""
responses = {}
for trade in trades:
commodity = trade.request.commodity
if commodity == self.fuel_outcommod:
mat_list = self.waste.pop_n(self.waste.count)
if len(mat_list) > 1:
for mat in mat_list[1:]:
mat_list[0].absorb(mat)
responses[trade] = mat_list[0]
return responses
def get_material_requests(self):
""" Ask for fuel_incommod"""
ports = []
if self.context.time == self.decom_time:
return []
if self.is_core_full():
return []
recipes = {}
qty = {}
mat = {}
t = self.context.time
# initial core loading
if self.batch_gen == 0:
enr_to_request = self.enr_matrix
for i in range(np.shape(enr_to_request)[0]):
for j in range(np.shape(enr_to_request)[1]):
enr = eval(enr_to_request[i,j])
comp = {'u-238': 100-enr,
'u-235': enr}
qty = self.assem_size
mat = ts.Material.create_untracked(qty, comp)
ports.append({'commodities': {self.fuel_incommod: mat},
'constraints': qty})
# subsequent equilibrium batch loading
else:
enr_to_request = self.enr_matrix[-1]
for enrichment in enr_to_request:
enr = eval(enrichment)
comp = {'u-238': 100-enr,
'u-235': enr}
qty = self.assem_size
mat = ts.Material.create_untracked(qty, comp)
ports.append({'commodities' : {self.fuel_incommod: mat},
'constraints': qty})
return ports
def accept_material_trades(self, responses):
""" Get fuel_incommod and store it into core"""
for key, mat in responses.items():
if key.request.commodity == self.fuel_incommod:
self.core.push(mat)
def is_core_full(self):
if self.core.count == self.n_assem_core:
return True
else:
return False
def predict(self, enr_bu):
model = self.model_dict['model']
x = self.model_dict['xscaler'].transform(enr_bu)
y = self.model_dict['yscaler'].inverse_transform(
model.predict(x))[0]
comp_dict = {}
for indx, iso in enumerate(self.iso_list):
# zero if model predicts negative
if y[indx] < 0:
y[indx] = 0
comp_dict[iso] = y[indx]
return comp_dict
def transmute_and_discharge(self, bu_list, enr_list):
# this should ideally be one batch,
t = self.context.time
if self.batch_gen < self.n_batch:
enr = enr_list[self.batch_gen]
else:
enr = enr_list[-1]
for indx, bu in enumerate(bu_list):
enr_bu = [[eval(enr_list[indx]),eval(bu)]]
print('Transmuting fuel with enrichment, burnup:')
print(enr_bu)
discharge_fuel = self.core.pop()
comp = self.predict(enr_bu)
discharge_fuel.transmute(comp)
self.waste.push(discharge_fuel)
def produce_power(self, produce=True):
if produce:
lib.record_time_series(lib.POWER, self, float(self.power_cap))
else:
lib.record_time_series(lib.POWER, self, 0)
def check_enr_bu_matrix(self):
# parse bu enr matrix
empty = np.zeros(len(self.enr_bu_matrix[0].split(' ')))
for i in self.enr_bu_matrix:
entry = np.array(i.split(' '))
if len(entry) != self.n_assem_batch:
raise ValueError('The length of entry has to match n_assem_batch')
try:
empty = np.vstack((empty, entry))
except ValueError:
print('Your length of entries per batch are inconsistent!')
matrix = empty[1:]
# separate bu and enrichment
sep = np.char.split(matrix, '_')
bu_matrix = np.empty(np.shape(matrix), dtype=object)
enr_matrix = np.empty(np.shape(matrix), dtype=object)
for i in range(np.shape(sep)[0]):
for j in range(np.shape(sep)[1]):
enr_matrix[i,j] = sep[i,j][0]
bu_matrix[i,j] = sep[i,j][1]
return enr_matrix, bu_matrix
class NOInst(Institution):
"""
This institution deploys facilities based on demand curves using
Non Optimizing (NO) methods.
"""
prototypes = ts.VectorString(
doc="A list of prototypes that the institution will draw upon to fit" +
"the demand curve",
tooltip="List of prototypes the institution can use to meet demand",
uilabel="Prototypes",
uitype="oneOrMore")
growth_rate = ts.Double(
doc="This value represents the growth rate that the institution is " +
"attempting to meet.",
tooltip="Growth rate of growth commodity",
uilabel="Growth Rate")
growth_commod = ts.String(
doc=
"The commodity this institution will be monitoring for demand growth. "
+ "The default value of this field is electric power.",
tooltip="Growth commodity",
uilabel="Growth Commodity")
initial_demand = ts.Double(doc="The initial power of the facility",
tooltip="Initital demand",
uilabel="Initial demand")
#The supply of a commodity
commodity_supply = {}
def tick(self):
"""
#Method for the deployment of facilities.
"""
if self.growth_commod not in lib.TIME_SERIES_LISTENERS:
lib.TIME_SERIES_LISTENERS[self.growth_commod].append(
self.extract_supply)
time = self.context.time
if time is 0:
return
print(self.commodity_supply[time - 1], self.demand_calc(time))
if self.commodity_supply[time - 1] < self.demand_calc(time):
proto = random.choice(self.prototypes)
print("New fac: " + proto)
print(self.kind)
self.context.schedule_build(self, proto)
def extract_supply(self, agent, time, value):
"""
Gather information on the available supply of a commodity over the
lifetime of the simulation.
"""
if time in self.commodity_supply:
self.commodity_supply[time] += value
else:
self.commodity_supply[time] = value
def demand_calc(self, time):
"""
Calculate the electrical demand at a given timestep (time).
Parameters
----------
time : int
The timestep that the demand will be calculated at.
"""
timestep = self.context.dt / 86400 / 28
demand = self.initial_demand * (
(1.0 + self.growth_rate)**(time / timestep))
return demand
class DeterministicInst(Institution):
"""
This institution deploys facilities based on demand curves using
time series methods.
"""
demand_eq = ts.String(
doc="This is the string for the demand equation of the driving commodity. " +
"The equation should use `t' as the dependent variable",
tooltip="Demand equation for driving commodity",
uilabel="Demand Equation"
)
prototypes = ts.VectorString(
doc="A list of the prototypes controlled by the institution.",
tooltip="List of prototypes in the institution.",
uilabel="Prototypes",
uitype="oneOrMore"
)
fac_rates = ts.VectorString(
doc="This is the string for the demand equation of the driving commodity. " +
"The equation should use `t' as the dependent variable",
tooltip="Demand equation for driving commodity",
uitype="oneOrMore",
uilabel="Demand Equation"
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.commods = {}
self.construct = []
self.demand = [0]
def enter_notify(self):
super().enter_notify()
for proto in self.prototypes:
self.construct.append(0)
def decision(self):
self.commods, matrix = self.construct_matrix()
t = self.context.time
self.demand.append(self.demand_calc(t+1))
demand = self.demand[-1] - self.demand[-2]
results = [0]*len(self.prototypes)
results[0] = demand
solve = []
for proto in self.prototypes:
solve.append(matrix[proto])
out = np.linalg.solve(solve, results)
print(out)
print(self.construct)
for i in range(len(out)):
self.construct[i] += out[i]
print(self.construct)
for i in range(len(self.construct)):
j = 0
while j < self.construct[i]:
self.context.schedule_build(self, self.prototypes[i])
self.construct[i] -= 1
j+=1
def construct_matrix(self):
matrix = {}
commodities = {}
for i in range(len(self.prototypes)):
proto = self.prototypes[i]
matrix[proto] = np.array(self.fac_rates[i].split(",")).astype(float)
return commodities, matrix
'''
def extract_supply(self, agent, time, value, commod):
"""
Gather information on the available supply of a commodity over the
lifetime of the simulation.
Parameters
----------
agent : cyclus agent
This is the agent that is making the call to the listener.
time : int
Timestep that the call is made.
value : object
This is the value of the object being recorded in the time
series.
"""
commod = commod[6:]
self.commodity_supply[commod][time] += value
# update commodities
# self.commodity_dict[commod] = {agent.prototype: value}
def extract_demand(self, agent, time, value, commod):
"""
Gather information on the demand of a commodity over the
lifetime of the simulation.
Parameters
----------
agent : cyclus agent
This is the agent that is making the call to the listener.
time : int
Timestep that the call is made.
value : object
This is the value of the object being recorded in the time
series.
"""
commod = commod[6:]
self.commodity_demand[commod][time] += value
'''
def demand_calc(self, time):
"""
Calculate the electrical demand at a given timestep (time).
Parameters
----------
time : int
The timestep that the demand will be calculated at.
Returns
-------
demand : The calculated demand at a given timestep.
"""
t = time
demand = eval(self.demand_eq)
return demand