Cycamore Archetypes¶
This is a collection of archetypes found in the cycamore module that comes with
cycamore itself.
:cycamore:Source¶
This facility acts as a source of material with a fixed throughput (per time step) capacity and a lifetime capacity defined by a total inventory size. It offers its material as a single commodity. If a composition recipe is specified, it provides that single material composition to requesters. If unspecified, the source provides materials with the exact requested compositions. The inventory size and throughput both default to infinite. Supplies material results in corresponding decrease in inventory, and when the inventory size reaches zero, the source can provide no more material.
State Variables¶
- outcommod:
std::string, shape=[-1]Output commodity on which the source offers material.
XML:
<outcommod>[outcommodity]</outcommod>
JSON:
{"outcommod": "<required>"} # outcommodity
Python:
{"outcommod": ""} # outcommodity, required
- outrecipe:
std::string, optional (default=””), shape=[-1]Name of composition recipe that this source provides regardless of requested composition. If empty, source creates and provides whatever compositions are requested.
XML:
<outrecipe>[outrecipe]</outrecipe>
JSON:
{"outrecipe": ""} # outrecipe
Python:
{"outrecipe": ''} # outrecipe, optional
- inventory_size:
double, optional (default=1e+299), shape=[-1]Total amount of material this source has remaining. Every trade decreases this value by the supplied material quantity. When it reaches zero, the source cannot provide any more material.
- range:
[0.0, 1e+299]
XML:
<inventory_size>[double ( kg )]</inventory_size>
JSON:
{"inventory_size": 1e+299} # double, kg
Python:
{"inventory_size": 1e+299} # double, kg, optional
- throughput:
double, optional (default=1e+299), shape=[-1]amount of commodity that can be supplied at each time step
- range:
[0.0, 1e+299]
XML:
<throughput>[double ( kg/(time step) )]</throughput>
JSON:
{"throughput": 1e+299} # double, kg/(time step)
Python:
{"throughput": 1e+299} # double, kg/(time step), optional
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::Source
Simulation Entity Type: facility
Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::CommodityProducer’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::CommodityProducer’, ‘cyclus::toolkit::Position’]
XML Input Schema¶
<interleave>
<element name="outcommod">
<data type="string"/>
</element>
<optional>
<element name="outrecipe">
<data type="string"/>
</element>
</optional>
<optional>
<element name="inventory_size">
<data type="double"/>
</element>
</optional>
<optional>
<element name="throughput">
<data type="double"/>
</element>
</optional>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:Sink¶
A sink facility that accepts materials and products with a fixed throughput (per time step) capacity and a lifetime capacity defined by a total inventory size. The inventory size and throughput capacity both default to infinite. If a recipe is provided, it will request material with that recipe. Requests are made for any number of specified commodities.
State Variables¶
- in_commods:
std::vector<std::string>, shape=[-1, -1]commodities that the sink facility accepts
XML:
<in_commods> <val>[incommodity]</val> <val>[incommodity]</val> ... </in_commods>
JSON:
{"in_commods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"in_commods": {"val": [ "", "", ... ]}}
- in_commod_prefs:
std::vector<double>, optional (default=[]), shape=[-1, -1]preferences for each of the given commodities, in the same order.Defauts to 1 if unspecified
- range:
[None, [1e-299, 1e+299]]
XML:
<in_commod_prefs> <val>[double]</val> <val>[double]</val> ... </in_commod_prefs>
JSON:
{"in_commod_prefs": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"in_commod_prefs": {"val": [ 0.0, 0.0, ... ]}}
- recipe_name:
std::string, optional (default=””), shape=[-1]name of recipe to use for material requests, where the default (empty string) is to accept everything
XML:
<recipe_name>[inrecipe]</recipe_name>
JSON:
{"recipe_name": ""} # inrecipe
Python:
{"recipe_name": ''} # inrecipe, optional
- max_inv_size:
double, optional (default=1e+299), shape=[-1]total maximum inventory size of sink facility
- range:
[0.0, 1e+299]
XML:
<max_inv_size>[double]</max_inv_size>
JSON:
{"max_inv_size": 1e+299} # double
Python:
{"max_inv_size": 1e+299} # double, optional
- capacity:
double, optional (default=1e+299), shape=[-1]capacity the sink facility can accept at each time step
- range:
[0.0, 1e+299]
XML:
<capacity>[double]</capacity>
JSON:
{"capacity": 1e+299} # double
Python:
{"capacity": 1e+299} # double, optional
- random_size_type:
std::string, optional (default=”None”), shape=[-1]type of random behavior to use. Default None, other options are ‘UniformReal’, ‘UniformInt’, ‘NormalReal’, and ‘NormalInt’
- categorical:
[‘None’, ‘UniformReal’, ‘UniformInt’, ‘NormalReal’, ‘NormalInt’]
XML:
<random_size_type>[string]</random_size_type>
JSON:
{"random_size_type": "None"} # string
Python:
{"random_size_type": 'None'} # string, optional
- random_size_mean:
double, optional (default=1.0), shape=[-1]When a normal distribution is used to determine the size of the request, this is the fraction of available space to use as the mean. Default 1.0. Note that values significantly above 1 without a correspondingly large std dev may result in inefficient use of the random number generator.
- range:
[0.0, 1e+299]
XML:
<random_size_mean>[double]</random_size_mean>
JSON:
{"random_size_mean": 1.0} # double
Python:
{"random_size_mean": 1.0} # double, optional
- random_size_stddev:
double, optional (default=0.1), shape=[-1]When a normal distribution is used to determine the size of the request, this is the fraction of available space to use as the standard deviation. Default 0.1
- range:
[0.0, 1e+299]
XML:
<random_size_stddev>[double]</random_size_stddev>
JSON:
{"random_size_stddev": 0.1} # double
Python:
{"random_size_stddev": 0.1} # double, optional
- random_frequency_type:
std::string, optional (default=”None”), shape=[-1]type of random behavior to use. Default None, other options are, ‘UniformInt’, and ‘NormalInt’. When using ‘UniformInt’, also set ‘random_frequency_min’ and ‘random_frequency_max’. For ‘NormalInt’, set ‘random_frequency_mean’ and ‘random_fequency_stddev’, min and max values are optional.
- categorical:
[‘None’, ‘UniformInt’, ‘NormalInt’]
XML:
<random_frequency_type>[string]</random_frequency_type>
JSON:
{"random_frequency_type": "None"} # string
Python:
{"random_frequency_type": 'None'} # string, optional
- random_frequency_mean:
double, optional (default=1), shape=[-1]When a normal distribution is used to determine the frequency of the request, this is the mean. Default 1
- range:
[0.0, 1e+299]
XML:
<random_frequency_mean>[double]</random_frequency_mean>
JSON:
{"random_frequency_mean": 1} # double
Python:
{"random_frequency_mean": 1} # double, optional
- random_frequency_stddev:
double, optional (default=1), shape=[-1]When a normal distribution is used to determine the frequency of the request, this is the standard deviation. Default 1
- range:
[0.0, 1e+299]
XML:
<random_frequency_stddev>[double]</random_frequency_stddev>
JSON:
{"random_frequency_stddev": 1} # double
Python:
{"random_frequency_stddev": 1} # double, optional
- random_frequency_min:
int, optional (default=1), shape=[-1]When a random distribution is used to determine the frequency of the request, this is the lower bound. Default 1
- range:
[1, 1e+299]
XML:
<random_frequency_min>[int]</random_frequency_min>
JSON:
{"random_frequency_min": 1} # int
Python:
{"random_frequency_min": 1} # int, optional
- random_frequency_max:
int, optional (default=1e+299), shape=[-1]When a random distribution is used to determine the frequency of the request, this is the upper bound. Default 1e299
- range:
[1, 1e+299]
XML:
<random_frequency_max>[int]</random_frequency_max>
JSON:
{"random_frequency_max": 1e+299} # int
Python:
{"random_frequency_max": 1e+299} # int, optional
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::Sink
Simulation Entity Type: facility
Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::Position’]
XML Input Schema¶
<interleave>
<element name="in_commods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="in_commod_prefs">
<oneOrMore>
<element name="val">
<data type="double"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="recipe_name">
<data type="string"/>
</element>
</optional>
<optional>
<element name="max_inv_size">
<data type="double"/>
</element>
</optional>
<optional>
<element name="capacity">
<data type="double"/>
</element>
</optional>
<optional>
<element name="random_size_type">
<data type="string"/>
</element>
</optional>
<optional>
<element name="random_size_mean">
<data type="double"/>
</element>
</optional>
<optional>
<element name="random_size_stddev">
<data type="double"/>
</element>
</optional>
<optional>
<element name="random_frequency_type">
<data type="string"/>
</element>
</optional>
<optional>
<element name="random_frequency_mean">
<data type="double"/>
</element>
</optional>
<optional>
<element name="random_frequency_stddev">
<data type="double"/>
</element>
</optional>
<optional>
<element name="random_frequency_min">
<data type="int"/>
</element>
</optional>
<optional>
<element name="random_frequency_max">
<data type="int"/>
</element>
</optional>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:Enrichment¶
The Enrichment facility is a simple agent that enriches natural uranium in a Cyclus simulation. It does not explicitly compute the physical enrichment process, rather it calculates the SWU required to convert a source uranium recipe (i.e. natural uranium) into a requested enriched recipe (i.e. 4% enriched uranium), given the natural uranium inventory constraint and its SWU capacity constraint.
The Enrichment facility requests an input commodity and associated recipe whose quantity is its remaining inventory capacity. All facilities trading the same input commodity (even with different recipes) will offer materials for trade. The Enrichment facility accepts any input materials with enrichments less than its tails assay, as long as some U235 is present, and preference increases with U235 content. If no U235 is present in the offered material, the trade preference is set to -1 and the material is not accepted. Any material components other than U235 and U238 are sent directly to the tails buffer.
The Enrichment facility will bid on any request for its output commodity up to the maximum allowed enrichment (if not specified, default is 100%) It bids on either the request quantity, or the maximum quanity allowed by its SWU constraint or natural uranium inventory, whichever is lower. If multiple output commodities with different enrichment levels are requested and the facility does not have the SWU or quantity capacity to meet all requests, the requests are fully, then partially filled in unspecified but repeatable order. A request for the product commodity without an associated requested enriched recipe will not be fulfilled.
Accumulated tails inventory is offered for trading as a specifiable output commodity.
State Variables¶
- feed_commod:
std::string, shape=[-1]feed commodity that the enrichment facility accepts
XML:
<feed_commod>[incommodity]</feed_commod>
JSON:
{"feed_commod": "<required>"} # incommodity
Python:
{"feed_commod": ""} # incommodity, required
- feed_recipe:
std::string, shape=[-1]recipe for enrichment facility feed commodity
XML:
<feed_recipe>[inrecipe]</feed_recipe>
JSON:
{"feed_recipe": "<required>"} # inrecipe
Python:
{"feed_recipe": ""} # inrecipe, required
- product_commod:
std::string, shape=[-1]product commodity that the enrichment facility generates
XML:
<product_commod>[outcommodity]</product_commod>
JSON:
{"product_commod": "<required>"} # outcommodity
Python:
{"product_commod": ""} # outcommodity, required
- tails_commod:
std::string, shape=[-1]tails commodity supplied by enrichment facility
XML:
<tails_commod>[outcommodity]</tails_commod>
JSON:
{"tails_commod": "<required>"} # outcommodity
Python:
{"tails_commod": ""} # outcommodity, required
- tails_assay:
double, optional (default=0.003), shape=[-1]tails assay from the enrichment process
- range:
[0.0, 0.003]
XML:
<tails_assay>[double]</tails_assay>
JSON:
{"tails_assay": 0.003} # double
Python:
{"tails_assay": 0.003} # double, optional
- initial_feed:
double, optional (default=0), shape=[-1]amount of natural uranium stored at the enrichment facility at the beginning of the simulation (kg)
XML:
<initial_feed>[double]</initial_feed>
JSON:
{"initial_feed": 0} # double
Python:
{"initial_feed": 0} # double, optional
- max_feed_inventory:
double, optional (default=1e+299), shape=[-1]maximum total inventory of natural uranium in the enrichment facility (kg)
- range:
[0.0, 1e+299]
XML:
<max_feed_inventory>[double]</max_feed_inventory>
JSON:
{"max_feed_inventory": 1e+299} # double
Python:
{"max_feed_inventory": 1e+299} # double, optional
- max_enrich:
double, optional (default=1.0), shape=[-1]maximum allowed weight fraction of U235 in product
- range:
[0.0, 1.0]
- schema:
<optional> <element name=”max_enrich”> <data type=”double”> <param name=”minInclusive”>0</param> <param name=”maxInclusive”>1</param> </data> </element> </optional>
XML:
<max_enrich>[double]</max_enrich>
JSON:
{"max_enrich": 1.0} # double
Python:
{"max_enrich": 1.0} # double, optional
- order_prefs:
bool, optional (default=1), shape=[-1]turn on preference ordering for input material so that EF chooses higher U235 content first
- userlevel:
10
XML:
<order_prefs>[boolean]</order_prefs>
JSON:
{"order_prefs": 1} # boolean
Python:
{"order_prefs": True} # boolean, optional
- swu_capacity:
double, optional (default=1e+299), shape=[-1]separative work unit (SWU) capacity of enrichment facility (kgSWU/timestep)
- range:
[0.0, 1e+299]
XML:
<swu_capacity>[double]</swu_capacity>
JSON:
{"swu_capacity": 1e+299} # double
Python:
{"swu_capacity": 1e+299} # double, optional
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::Enrichment
Simulation Entity Type: facility
Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::Position’]
niche: enrichment facility
XML Input Schema¶
<interleave>
<element name="feed_commod">
<data type="string"/>
</element>
<element name="feed_recipe">
<data type="string"/>
</element>
<element name="product_commod">
<data type="string"/>
</element>
<element name="tails_commod">
<data type="string"/>
</element>
<optional>
<element name="tails_assay">
<data type="double"/>
</element>
</optional>
<optional>
<element name="initial_feed">
<data type="double"/>
</element>
</optional>
<optional>
<element name="max_feed_inventory">
<data type="double"/>
</element>
</optional>
<optional>
<element name="max_enrich">
<data type="double">
<param name="minInclusive">0</param>
<param name="maxInclusive">1</param>
</data>
</element>
</optional>
<optional>
<element name="order_prefs">
<data type="boolean"/>
</element>
</optional>
<optional>
<element name="swu_capacity">
<data type="double"/>
</element>
</optional>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:Reactor¶
Reactor is a simple, general reactor based on static compositional transformations to model fuel burnup. The user specifies a set of input fuels and corresponding burnt compositions that fuel is transformed to when it is discharged from the core. No incremental transmutation takes place. Rather, at the end of an operational cycle, the batch being discharged from the core is instantaneously transmuted from its original fresh fuel composition into its spent fuel form.
Each fuel is identified by a specific input commodity and has an associated input recipe (nuclide composition), output recipe, output commidity, and preference. The preference identifies which input fuels are preferred when requesting. Changes in these preferences can be specified as a function of time using the pref_change variables. Changes in the input-output recipe compositions can also be specified as a function of time using the recipe_change variables.
The reactor treats fuel as individual assemblies that are never split, combined or otherwise treated in any non-discrete way. Fuel is requested in full-or-nothing assembly sized quanta. If real-world assembly modeling is unnecessary, parameters can be adjusted (e.g. n_assem_core, assem_size, n_assem_batch). At the end of every cycle, a full batch is discharged from the core consisting of n_assem_batch assemblies of assem_size kg. The reactor also has a specifiable refueling time period following the end of each cycle at the end of which it will resume operation on the next cycle if it has enough fuel for a full core; otherwise it waits until it has enough fresh fuel assemblies.
In addition to its core, the reactor has an on-hand fresh fuel inventory and a spent fuel inventory whose capacities are specified by n_assem_fresh and n_assem_spent respectively. Each time step the reactor will attempt to acquire enough fresh fuel to fill its fresh fuel inventory (and its core if the core isn’t currently full). If the fresh fuel inventory has zero capacity, fuel will be ordered just-in-time after the end of each operational cycle before the next begins. If the spent fuel inventory becomes full, the reactor will halt operation at the end of the next cycle until there is more room. Each time step, the reactor will try to trade away as much of its spent fuel inventory as possible.
When the reactor reaches the end of its lifetime, it will discharge all material from its core and trade away all its spent fuel as quickly as possible. Full decommissioning will be delayed until all spent fuel is gone. If the reactor has a full core when it is decommissioned (i.e. is mid-cycle) when the reactor is decommissioned, half (rounded up to nearest int) of its assemblies are transmuted to their respective burnt compositions.
State Variables¶
- fuel_incommods:
std::vector<std::string>, shape=[-1, -1]Ordered list of input commodities on which to requesting fuel.
XML:
<fuel_incommods> <val>[incommodity]</val> <val>[incommodity]</val> ... </fuel_incommods>
JSON:
{"fuel_incommods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fuel_incommods": {"val": [ "", "", ... ]}}
- fuel_inrecipes:
std::vector<std::string>, shape=[-1, -1]Fresh fuel recipes to request for each of the given fuel input commodities (same order).
XML:
<fuel_inrecipes> <val>[inrecipe]</val> <val>[inrecipe]</val> ... </fuel_inrecipes>
JSON:
{"fuel_inrecipes": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fuel_inrecipes": {"val": [ "", "", ... ]}}
- fuel_prefs:
std::vector<double>, optional (default=[]), shape=[-1, -1]The preference for each type of fresh fuel requested corresponding to each input commodity (same order). If no preferences are specified, 1.0 is used for all fuel requests (default).
XML:
<fuel_prefs> <val>[double]</val> <val>[double]</val> ... </fuel_prefs>
JSON:
{"fuel_prefs": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fuel_prefs": {"val": [ 0.0, 0.0, ... ]}}
- fuel_outcommods:
std::vector<std::string>, shape=[-1, -1]Output commodities on which to offer spent fuel originally received as each particular input commodity (same order).
XML:
<fuel_outcommods> <val>[outcommodity]</val> <val>[outcommodity]</val> ... </fuel_outcommods>
JSON:
{"fuel_outcommods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fuel_outcommods": {"val": [ "", "", ... ]}}
- fuel_outrecipes:
std::vector<std::string>, shape=[-1, -1]Spent fuel recipes corresponding to the given fuel input commodities (same order). Fuel received via a particular input commodity is transmuted to the recipe specified here after being burned during a cycle.
XML:
<fuel_outrecipes> <val>[outrecipe]</val> <val>[outrecipe]</val> ... </fuel_outrecipes>
JSON:
{"fuel_outrecipes": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fuel_outrecipes": {"val": [ "", "", ... ]}}
- recipe_change_times:
std::vector<int>, optional (default=[]), shape=[-1, -1]A time step on which to change the input-output recipe pair for a requested fresh fuel.
XML:
<recipe_change_times> <val>[int]</val> <val>[int]</val> ... </recipe_change_times>
JSON:
{"recipe_change_times": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"recipe_change_times": {"val": [ 0, 0, ... ]}}
- recipe_change_commods:
std::vector<std::string>, optional (default=[]), shape=[-1, -1]The input commodity indicating fresh fuel for which recipes will be changed. Same order as and direct correspondence to the specified recipe change times.
XML:
<recipe_change_commods> <val>[incommodity]</val> <val>[incommodity]</val> ... </recipe_change_commods>
JSON:
{"recipe_change_commods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"recipe_change_commods": {"val": [ "", "", ... ]}}
- recipe_change_in:
std::vector<std::string>, optional (default=[]), shape=[-1, -1]The new input recipe to use for this recipe change. Same order as and direct correspondence to the specified recipe change times.
XML:
<recipe_change_in> <val>[inrecipe]</val> <val>[inrecipe]</val> ... </recipe_change_in>
JSON:
{"recipe_change_in": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"recipe_change_in": {"val": [ "", "", ... ]}}
- recipe_change_out:
std::vector<std::string>, optional (default=[]), shape=[-1, -1]The new output recipe to use for this recipe change. Same order as and direct correspondence to the specified recipe change times.
XML:
<recipe_change_out> <val>[outrecipe]</val> <val>[outrecipe]</val> ... </recipe_change_out>
JSON:
{"recipe_change_out": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"recipe_change_out": {"val": [ "", "", ... ]}}
- assem_size:
double, shape=[-1]Mass (kg) of a single assembly.
- range:
[1.0, 100000.0]
XML:
<assem_size>[double ( kg )]</assem_size>
JSON:
{"assem_size": "<required>"} # double, kg
Python:
{"assem_size": 0.0} # double, kg, required
- n_assem_batch:
int, shape=[-1]Number of assemblies that constitute a single batch. This is the number of assemblies discharged from the core fully burned each cycle.Batch size is equivalent to
n_assem_batch / n_assem_core.XML:
<n_assem_batch>[int]</n_assem_batch>
JSON:
{"n_assem_batch": "<required>"} # int
Python:
{"n_assem_batch": 0} # int, required
- n_assem_core:
int, optional (default=3), shape=[-1]Number of assemblies that constitute a full core.
- range:
[1, 3]
XML:
<n_assem_core>[int]</n_assem_core>
JSON:
{"n_assem_core": 3} # int
Python:
{"n_assem_core": 3} # int, optional
- n_assem_fresh:
int, optional (default=0), shape=[-1]Number of fresh fuel assemblies to keep on-hand if possible.
- range:
[0, 3]
XML:
<n_assem_fresh>[int ( assemblies )]</n_assem_fresh>
JSON:
{"n_assem_fresh": 0} # int, assemblies
Python:
{"n_assem_fresh": 0} # int, assemblies, optional
- n_assem_spent:
int, optional (default=1000000000), shape=[-1]Number of spent fuel assemblies that can be stored on-site before reactor operation stalls.
- range:
[0, 1000000000]
XML:
<n_assem_spent>[int ( assemblies )]</n_assem_spent>
JSON:
{"n_assem_spent": 1000000000} # int, assemblies
Python:
{"n_assem_spent": 1000000000} # int, assemblies, optional
- cycle_time:
int, optional (default=18), shape=[-1]The duration of a full operational cycle (excluding refueling time) in time steps.
XML:
<cycle_time>[int ( time steps )]</cycle_time>
JSON:
{"cycle_time": 18} # int, time steps
Python:
{"cycle_time": 18} # int, time steps, optional
- refuel_time:
int, optional (default=1), shape=[-1]The duration of a full refueling period - the minimum time between the end of a cycle and the start of the next cycle.
XML:
<refuel_time>[int ( time steps )]</refuel_time>
JSON:
{"refuel_time": 1} # int, time steps
Python:
{"refuel_time": 1} # int, time steps, optional
- cycle_step:
int, optional (default=0), shape=[-1]Number of time steps since the start of the last cycle. Only set this if you know what you are doing
XML:
<cycle_step>[int ( time steps )]</cycle_step>
JSON:
{"cycle_step": 0} # int, time steps
Python:
{"cycle_step": 0} # int, time steps, optional
- power_cap:
double, optional (default=0), shape=[-1]Amount of electrical power the facility produces when operating normally.
- range:
[0.0, 2000.0]
XML:
<power_cap>[double ( MWe )]</power_cap>
JSON:
{"power_cap": 0} # double, MWe
Python:
{"power_cap": 0} # double, MWe, optional
- power_name:
std::string, optional (default=”power”), shape=[-1]The name of the ‘power’ commodity used in conjunction with a deployment curve.
XML:
<power_name>[string]</power_name>
JSON:
{"power_name": "power"} # string
Python:
{"power_name": 'power'} # string, optional
- side_products:
std::vector<std::string>, optional (default=[]), shape=[-1, -1]Ordered vector of side product the reactor produces with power
XML:
<side_products> <val>[string]</val> <val>[string]</val> ... </side_products>
JSON:
{"side_products": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"side_products": {"val": [ "", "", ... ]}}
- side_product_quantity:
std::vector<double>, optional (default=[]), shape=[-1, -1]Ordered vector of the quantity of side product the reactor produces with power
XML:
<side_product_quantity> <val>[double]</val> <val>[double]</val> ... </side_product_quantity>
JSON:
{"side_product_quantity": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"side_product_quantity": {"val": [ 0.0, 0.0, ... ]}}
- decom_transmute_all:
bool, optional (default=0), shape=[-1]If true, the archetype transmutes all assemblies upon decommissioning If false, the archetype only transmutes half.
XML:
<decom_transmute_all>[boolean]</decom_transmute_all>
JSON:
{"decom_transmute_all": 0} # boolean
Python:
{"decom_transmute_all": False} # boolean, optional
- pref_change_times:
std::vector<int>, optional (default=[]), shape=[-1, -1]A time step on which to change the request preference for a particular fresh fuel type.
XML:
<pref_change_times> <val>[int]</val> <val>[int]</val> ... </pref_change_times>
JSON:
{"pref_change_times": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"pref_change_times": {"val": [ 0, 0, ... ]}}
- pref_change_commods:
std::vector<std::string>, optional (default=[]), shape=[-1, -1]The input commodity for a particular fuel preference change. Same order as and direct correspondence to the specified preference change times.
XML:
<pref_change_commods> <val>[incommodity]</val> <val>[incommodity]</val> ... </pref_change_commods>
JSON:
{"pref_change_commods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"pref_change_commods": {"val": [ "", "", ... ]}}
- pref_change_values:
std::vector<double>, optional (default=[]), shape=[-1, -1]The new/changed request preference for a particular fresh fuel. Same order as and direct correspondence to the specified preference change times.
XML:
<pref_change_values> <val>[double]</val> <val>[double]</val> ... </pref_change_values>
JSON:
{"pref_change_values": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"pref_change_values": {"val": [ 0.0, 0.0, ... ]}}
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::Reactor
Simulation Entity Type: facility
Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::CommodityProducer’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::CommodityProducer’, ‘cyclus::toolkit::Position’]
niche: reactor
XML Input Schema¶
<interleave>
<element name="fuel_incommods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<element name="fuel_inrecipes">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="fuel_prefs">
<oneOrMore>
<element name="val">
<data type="double"/>
</element>
</oneOrMore>
</element>
</optional>
<element name="fuel_outcommods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<element name="fuel_outrecipes">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="recipe_change_times">
<oneOrMore>
<element name="val">
<data type="int"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="recipe_change_commods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="recipe_change_in">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="recipe_change_out">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
</optional>
<element name="assem_size">
<data type="double"/>
</element>
<element name="n_assem_batch">
<data type="int"/>
</element>
<optional>
<element name="n_assem_core">
<data type="int"/>
</element>
</optional>
<optional>
<element name="n_assem_fresh">
<data type="int"/>
</element>
</optional>
<optional>
<element name="n_assem_spent">
<data type="int"/>
</element>
</optional>
<optional>
<element name="cycle_time">
<data type="int"/>
</element>
</optional>
<optional>
<element name="refuel_time">
<data type="int"/>
</element>
</optional>
<optional>
<element name="cycle_step">
<data type="int"/>
</element>
</optional>
<optional>
<element name="power_cap">
<data type="double"/>
</element>
</optional>
<optional>
<element name="power_name">
<data type="string"/>
</element>
</optional>
<optional>
<element name="side_products">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="side_product_quantity">
<oneOrMore>
<element name="val">
<data type="double"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="decom_transmute_all">
<data type="boolean"/>
</element>
</optional>
<optional>
<element name="pref_change_times">
<oneOrMore>
<element name="val">
<data type="int"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="pref_change_commods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="pref_change_values">
<oneOrMore>
<element name="val">
<data type="double"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:Separations¶
Separations processes feed material into one or more streams containing specific elements and/or nuclides. It uses mass-based efficiencies.
User defined separations streams are specified as groups of component-efficiency pairs where ‘component’ means either a particular element or a particular nuclide. Each component’s paired efficiency represents the mass fraction of that component in the feed that is separated into that stream. The efficiencies of a particular component across all streams must sum up to less than or equal to one. If less than one, the remainining material is sent to a waste inventory and (potentially) traded away from there.
The facility receives material into a feed inventory that it processes with a specified throughput each time step. Each output stream has a corresponding output inventory size/limit. If the facility is unable to reduce its stocks by trading and hits this limit for any of its output streams, further processing/separations of feed material will halt until room is again available in the output streams.
State Variables¶
- feed_commods:
std::vector<std::string>, shape=[-1, -1]Ordered list of commodities on which to request feed material to separate. Order only matters for matching up with feed commodity preferences if specified.
XML:
<feed_commods> <val>[incommodity]</val> <val>[incommodity]</val> ... </feed_commods>
JSON:
{"feed_commods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"feed_commods": {"val": [ "", "", ... ]}}
- feed_commod_prefs:
std::vector<double>, optional (default=[]), shape=[-1, -1]Feed commodity request preferences for each of the given feed commodities (same order). If unspecified, default is to use 1.0 for all preferences.
XML:
<feed_commod_prefs> <val>[double]</val> <val>[double]</val> ... </feed_commod_prefs>
JSON:
{"feed_commod_prefs": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"feed_commod_prefs": {"val": [ 0.0, 0.0, ... ]}}
- feed_recipe:
std::string, optional (default=””), shape=[-1]Name for recipe to be used in feed requests. Empty string results in use of a dummy recipe.
XML:
<feed_recipe>[inrecipe]</feed_recipe>
JSON:
{"feed_recipe": ""} # inrecipe
Python:
{"feed_recipe": ''} # inrecipe, optional
- feedbuf_size:
double, shape=[-1]Maximum amount of feed material to keep on hand.
XML:
<feedbuf_size>[double ( kg )]</feedbuf_size>
JSON:
{"feedbuf_size": "<required>"} # double, kg
Python:
{"feedbuf_size": 0.0} # double, kg, required
- throughput:
double, optional (default=1e+299), shape=[-1]Maximum quantity of feed material that can be processed per time step.
- range:
[0.0, 1e+299]
XML:
<throughput>[double ( kg/(time step) )]</throughput>
JSON:
{"throughput": 1e+299} # double, kg/(time step)
Python:
{"throughput": 1e+299} # double, kg/(time step), optional
- leftover_commod:
std::string, optional (default=”default-waste-stream”), shape=[-1]Commodity on which to trade the leftover separated material stream. This MUST NOT be the same as any commodity used to define the other separations streams.
XML:
<leftover_commod>[outcommodity]</leftover_commod>
JSON:
{"leftover_commod": "default-waste-stream"} # outcommodity
Python:
{"leftover_commod": 'default-waste-stream'} # outcommodity, optional
- leftoverbuf_size:
double, optional (default=1e+299), shape=[-1]Maximum amount of leftover separated material (not included in any other stream) that can be stored. If full, the facility halts operation until space becomes available.
- range:
[0.0, 1e+299]
XML:
<leftoverbuf_size>[double ( kg )]</leftoverbuf_size>
JSON:
{"leftoverbuf_size": 1e+299} # double, kg
Python:
{"leftoverbuf_size": 1e+299} # double, kg, optional
- streams:
std::map<std::string, std::pair<double, std::map<int, double>>>, shape=[-1, -1, -1, -1, -1, -1, -1]Output streams for separations. Each stream must have a unique name identifying the commodity on which its material is traded, a max buffer capacity in kg (neg values indicate infinite size), and a set of component efficiencies. ‘comp’ is a component to be separated into the stream (e.g. U, Pu, etc.) and ‘eff’ is the mass fraction of the component that is separated from the feed into this output stream. If any stream buffer is full, the facility halts operation until space becomes available. The sum total of all component efficiencies across streams must be less than or equal to 1 (e.g. sum of U efficiencies for all streams must be <= 1).
XML:
<streams> <item> <commod>[outcommodity]</commod> <info> <buf_size>[double]</buf_size> <efficiencies> <item> <comp>[nuclide]</comp> <eff>[double]</eff> </item> <item> <comp>[nuclide]</comp> <eff>[double]</eff> </item> ... </efficiencies> </info> </item> <item> <commod>[outcommodity]</commod> <info> <buf_size>[double]</buf_size> <efficiencies> <item> <comp>[nuclide]</comp> <eff>[double]</eff> </item> <item> <comp>[nuclide]</comp> <eff>[double]</eff> </item> ... </efficiencies> </info> </item> ... </streams>
JSON:
{"streams": { "item": [{ "commod": "<required>", "info": { "buf_size": "<required>", "efficiencies": { "item": [{ "comp": "<required>", "eff": "<required>"}, {"comp": "<required>", "eff": "<required>"}, ... ]} } }, {"commod": "<required>", "info": { "buf_size": "<required>", "efficiencies": { "item": [{ "comp": "<required>", "eff": "<required>"}, {"comp": "<required>", "eff": "<required>"}, ... ]} } }, ... ]}}
Python:
{"streams": { "item": [{ "commod": "", "info": { "buf_size": 0.0, "efficiencies": { "item": [{ "comp": 0, "eff": 0.0}, {"comp": 0, "eff": 0.0}, ... ]} } }, {"commod": "", "info": { "buf_size": 0.0, "efficiencies": { "item": [{ "comp": 0, "eff": 0.0}, {"comp": 0, "eff": 0.0}, ... ]} } }, ... ]}}
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::Separations
Simulation Entity Type: facility
Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::Position’]
niche: separations
XML Input Schema¶
<interleave>
<element name="feed_commods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="feed_commod_prefs">
<oneOrMore>
<element name="val">
<data type="double"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="feed_recipe">
<data type="string"/>
</element>
</optional>
<element name="feedbuf_size">
<data type="double"/>
</element>
<optional>
<element name="throughput">
<data type="double"/>
</element>
</optional>
<optional>
<element name="leftover_commod">
<data type="string"/>
</element>
</optional>
<optional>
<element name="leftoverbuf_size">
<data type="double"/>
</element>
</optional>
<element name="streams">
<oneOrMore>
<element name="item">
<interleave>
<element name="commod">
<data type="string"/>
</element>
<element name="info">
<interleave>
<element name="buf_size">
<data type="double"/>
</element>
<element name="efficiencies">
<oneOrMore>
<element name="item">
<interleave>
<element name="comp">
<data type="string"/>
</element>
<element name="eff">
<data type="double"/>
</element>
</interleave>
</element>
</oneOrMore>
</element>
</interleave>
</element>
</interleave>
</element>
</oneOrMore>
</element>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:FuelFab¶
FuelFab takes in 2 streams of material and mixes them in ratios in order to supply material that matches some neutronics properties of reqeusted material. It uses an equivalence type method [1] inspired by a similar approach in the COSI fuel cycle simulator.
The FuelFab has 3 input inventories: fissile stream, filler stream, and an optional top-up inventory. All materials received into each inventory are always combined into a single material (i.e. a single fissile material, a single filler material, etc.). The input streams and requested fuel composition are each assigned weights based on summing:
N * (p_i - p_U238) / (p_Pu239 - p_U238)
for each nuclide where:
p = nu*sigma_f - sigma_a for the nuclide
p_U238 is p for pure U238
p_Pu239 is p for pure Pu239
N is the nuclide’s atom fraction
nu is the average # neutrons per fission
sigma_f is the microscopic fission cross-section
sigma_a is the microscopic neutron absorption cross-section
The cross sections are from the simple cross section library in PyNE. They can be set to either a thermal or fast neutron spectrum. A linear interpolation is performed using the weights of the fissile, filler, and target streams. The interpolation is used to compute a mixing ratio of the input streams that matches the target weight. In the event that the target weight is higher than the fissile stream weight, the FuelFab will attempt to use the top-up and fissile input streams together instead of the fissile and filler streams. All supplied material will always have the same weight as the requested material.
The supplying of mixed material is constrained by available inventory quantities and a per time step throughput limit. Requests for fuel material larger than the throughput can never be met. Fissile inventory can be requested/received via one or more commodities. The DRE request preference for each of these commodities can also optionally be specified. By default, the top-up inventory size is zero, and it is not used for mixing.
[1] Baker, A. R., and R. W. Ross. “Comparison of the value of plutonium and uranium isotopes in fast reactors.” Proceedings of the Conference on Breeding. Economics, and Safety in Large Fast Power Reactors. 1963.
State Variables¶
- fill_commods:
std::vector<std::string>, shape=[-1, -1]Ordered list of commodities on which to requesting filler stream material.
XML:
<fill_commods> <val>[incommodity]</val> <val>[incommodity]</val> ... </fill_commods>
JSON:
{"fill_commods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fill_commods": {"val": [ "", "", ... ]}}
- fill_commod_prefs:
std::vector<double>, optional (default=[]), shape=[-1, -1]Filler stream commodity request preferences for each of the given filler commodities (same order). If unspecified, default is to use 1.0 for all preferences.
XML:
<fill_commod_prefs> <val>[double]</val> <val>[double]</val> ... </fill_commod_prefs>
JSON:
{"fill_commod_prefs": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fill_commod_prefs": {"val": [ 0.0, 0.0, ... ]}}
- fill_recipe:
std::string, shape=[-1]Name of recipe to be used in filler material stream requests.
XML:
<fill_recipe>[inrecipe]</fill_recipe>
JSON:
{"fill_recipe": "<required>"} # inrecipe
Python:
{"fill_recipe": ""} # inrecipe, required
- fill_size:
double, shape=[-1]Size of filler material stream inventory.
XML:
<fill_size>[double ( kg )]</fill_size>
JSON:
{"fill_size": "<required>"} # double, kg
Python:
{"fill_size": 0.0} # double, kg, required
- fiss_commods:
std::vector<std::string>, shape=[-1, -1]Ordered list of commodities on which to requesting fissile stream material.
XML:
<fiss_commods> <val>[incommodity]</val> <val>[incommodity]</val> ... </fiss_commods>
JSON:
{"fiss_commods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fiss_commods": {"val": [ "", "", ... ]}}
- fiss_commod_prefs:
std::vector<double>, optional (default=[]), shape=[-1, -1]Fissile stream commodity request preferences for each of the given fissile commodities (same order). If unspecified, default is to use 1.0 for all preferences.
XML:
<fiss_commod_prefs> <val>[double]</val> <val>[double]</val> ... </fiss_commod_prefs>
JSON:
{"fiss_commod_prefs": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"fiss_commod_prefs": {"val": [ 0.0, 0.0, ... ]}}
- fiss_recipe:
std::string, optional (default=””), shape=[-1]Name for recipe to be used in fissile stream requests. Empty string results in use of an empty dummy recipe.
XML:
<fiss_recipe>[inrecipe]</fiss_recipe>
JSON:
{"fiss_recipe": ""} # inrecipe
Python:
{"fiss_recipe": ''} # inrecipe, optional
- fiss_size:
double, shape=[-1]Size of fissile material stream inventory.
XML:
<fiss_size>[double ( kg )]</fiss_size>
JSON:
{"fiss_size": "<required>"} # double, kg
Python:
{"fiss_size": 0.0} # double, kg, required
- topup_commod:
std::string, optional (default=””), shape=[-1]Commodity on which to request material for top-up stream. This MUST be set if ‘topup_size > 0’.
XML:
<topup_commod>[incommodity]</topup_commod>
JSON:
{"topup_commod": ""} # incommodity
Python:
{"topup_commod": ''} # incommodity, optional
- topup_pref:
double, optional (default=1.0), shape=[-1]Top-up material stream request preference.
XML:
<topup_pref>[double]</topup_pref>
JSON:
{"topup_pref": 1.0} # double
Python:
{"topup_pref": 1.0} # double, optional
- topup_recipe:
std::string, optional (default=””), shape=[-1]Name of recipe to be used in top-up material stream requests. This MUST be set if ‘topup_size > 0’.
XML:
<topup_recipe>[inrecipe]</topup_recipe>
JSON:
{"topup_recipe": ""} # inrecipe
Python:
{"topup_recipe": ''} # inrecipe, optional
- topup_size:
double, optional (default=0), shape=[-1]Size of top-up material stream inventory.
XML:
<topup_size>[double ( kg )]</topup_size>
JSON:
{"topup_size": 0} # double, kg
Python:
{"topup_size": 0} # double, kg, optional
- outcommod:
std::string, shape=[-1]Commodity on which to offer/supply mixed fuel material.
XML:
<outcommod>[outcommodity]</outcommod>
JSON:
{"outcommod": "<required>"} # outcommodity
Python:
{"outcommod": ""} # outcommodity, required
- throughput:
double, optional (default=1e+299), shape=[-1]Maximum number of kg of fuel material that can be supplied per time step.
- range:
[0.0, 1e+299]
XML:
<throughput>[double ( kg )]</throughput>
JSON:
{"throughput": 1e+299} # double, kg
Python:
{"throughput": 1e+299} # double, kg, optional
- spectrum:
std::string, shape=[-1]The type of cross-sections to use for composition property calculation. Use ‘fission_spectrum_ave’ for fast reactor compositions or ‘thermal’ for thermal reactors.
- categorical:
[‘fission_spectrum_ave’, ‘thermal’]
XML:
<spectrum>[string]</spectrum>
JSON:
{"spectrum": "<required>"} # string
Python:
{"spectrum": ""} # string, required
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::FuelFab
Simulation Entity Type: facility
Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::Position’]
niche: fabrication
XML Input Schema¶
<interleave>
<element name="fill_commods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="fill_commod_prefs">
<oneOrMore>
<element name="val">
<data type="double"/>
</element>
</oneOrMore>
</element>
</optional>
<element name="fill_recipe">
<data type="string"/>
</element>
<element name="fill_size">
<data type="double"/>
</element>
<element name="fiss_commods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="fiss_commod_prefs">
<oneOrMore>
<element name="val">
<data type="double"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="fiss_recipe">
<data type="string"/>
</element>
</optional>
<element name="fiss_size">
<data type="double"/>
</element>
<optional>
<element name="topup_commod">
<data type="string"/>
</element>
</optional>
<optional>
<element name="topup_pref">
<data type="double"/>
</element>
</optional>
<optional>
<element name="topup_recipe">
<data type="string"/>
</element>
</optional>
<optional>
<element name="topup_size">
<data type="double"/>
</element>
</optional>
<element name="outcommod">
<data type="string"/>
</element>
<optional>
<element name="throughput">
<data type="double"/>
</element>
</optional>
<element name="spectrum">
<data type="string"/>
</element>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:Storage¶
Storage is a simple facility which accepts any number of commodities and holds them for a user specified amount of time. The commodities accepted are chosen based on the specified preferences list. Once the desired amount of material has entered the facility it is passed into a ‘processing’ buffer where it is held until the residence time has passed. The material is then passed into a ‘ready’ buffer where it is queued for removal. Currently, all input commodities are lumped into a single output commodity. Storage also has the functionality to handle materials in discrete or continuous batches. Discrete mode, which is the default, does not split or combine material batches. Continuous mode, however, divides material batches if necessary in order to push materials through the facility as quickly as possible.
State Variables¶
- in_commods:
std::vector<std::string>, shape=[-1, -1]commodities accepted by this facility
XML:
<in_commods> <val>[incommodity]</val> <val>[incommodity]</val> ... </in_commods>
JSON:
{"in_commods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"in_commods": {"val": [ "", "", ... ]}}
- in_commod_prefs:
std::vector<double>, optional (default=[]), shape=[-1, -1]preferences for each of the given commodities, in the same order.Defauts to 1 if unspecified
- range:
[None, [1e-299, 1e+299]]
XML:
<in_commod_prefs> <val>[double]</val> <val>[double]</val> ... </in_commod_prefs>
JSON:
{"in_commod_prefs": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"in_commod_prefs": {"val": [ 0.0, 0.0, ... ]}}
- out_commods:
std::vector<std::string>, shape=[-1, -1]commodity produced by this facility. Multiple commodity tracking is currently not supported, one output commodity catches all input commodities.
XML:
<out_commods> <val>[outcommodity]</val> <val>[outcommodity]</val> ... </out_commods>
JSON:
{"out_commods": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"out_commods": {"val": [ "", "", ... ]}}
- in_recipe:
std::string, optional (default=””), shape=[-1]recipe accepted by this facility, if unspecified a dummy recipe is used
XML:
<in_recipe>[inrecipe]</in_recipe>
JSON:
{"in_recipe": ""} # inrecipe
Python:
{"in_recipe": ''} # inrecipe, optional
- residence_time:
int, optional (default=0), shape=[-1]the minimum holding time for a received commodity (timesteps).
- range:
[0, 12000]
XML:
<residence_time>[int ( time steps )]</residence_time>
JSON:
{"residence_time": 0} # int, time steps
Python:
{"residence_time": 0} # int, time steps, optional
- sell_quantity:
double, optional (default=0), shape=[-1]material will be sold in integer multiples of this quantity. If the buffer contains less than the sell quantity, no material will be offered
- range:
[0.0, 1e+299]
XML:
<sell_quantity>[double ( kg )]</sell_quantity>
JSON:
{"sell_quantity": 0} # double, kg
Python:
{"sell_quantity": 0} # double, kg, optional
- throughput:
double, optional (default=1e+299), shape=[-1]the max amount that can be moved through the facility per timestep (kg)
- range:
[0.0, 1e+299]
XML:
<throughput>[double ( kg )]</throughput>
JSON:
{"throughput": 1e+299} # double, kg
Python:
{"throughput": 1e+299} # double, kg, optional
- max_inv_size:
double, optional (default=1e+299), shape=[-1]the maximum amount of material that can be in all storage buffer stages
- range:
[0.0, 1e+299]
XML:
<max_inv_size>[double ( kg )]</max_inv_size>
JSON:
{"max_inv_size": 1e+299} # double, kg
Python:
{"max_inv_size": 1e+299} # double, kg, optional
- discrete_handling:
bool, optional (default=False), shape=[-1]Determines if Storage will divide resource objects. Only controls material handling within this facility, has no effect on DRE material handling. If true, batches are handled as discrete quanta, neither split nor combined. Otherwise, batches may be divided during processing. Default to false (continuous))
XML:
<discrete_handling>[boolean]</discrete_handling>
JSON:
{"discrete_handling": False} # boolean
Python:
{"discrete_handling": False} # boolean, optional
- active_buying_frequency_type:
std::string, optional (default=”Fixed”), shape=[-1]Options: Fixed, Uniform, Normal. Fixed requires active_buying_val. Uniform requires active_buying_min and active_buying_max. Normal requires active_buying_mean and active_buying_std, with optional active_buying_min and active_buying_max.
- categorical:
[‘Fixed’, ‘Uniform’, ‘Normal’]
XML:
<active_buying_frequency_type>[string]</active_buying_frequency_type>
JSON:
{"active_buying_frequency_type": "Fixed"} # string
Python:
{"active_buying_frequency_type": 'Fixed'} # string, optional
- active_buying_val:
int, optional (default=-1), shape=[-1]The length in time steps of the active buying period. Required for fixed active_buying_frequency_type. Must be greater than or equal to 1 (i.e., agent cannot always be dormant)
- range:
[1, 1e+299]
XML:
<active_buying_val>[int]</active_buying_val>
JSON:
{"active_buying_val": -1} # int
Python:
{"active_buying_val": -1} # int, optional
- active_buying_min:
int, optional (default=-1), shape=[-1]The minimum length in time steps of the active buying period. Required for Uniform and optional for Normal active_buying_frequency_type. Must be greater than or equal to 1
- range:
[1, 1e+299]
XML:
<active_buying_min>[int]</active_buying_min>
JSON:
{"active_buying_min": -1} # int
Python:
{"active_buying_min": -1} # int, optional
- active_buying_max:
int, optional (default=-1), shape=[-1]The maximum length in time steps of the active buying period. Required for Uniform active_buying_frequency_type, optional for Normal. Must be greater than or equal to active_buying_min
- range:
[1, 1e+299]
XML:
<active_buying_max>[int]</active_buying_max>
JSON:
{"active_buying_max": -1} # int
Python:
{"active_buying_max": -1} # int, optional
- active_buying_mean:
double, optional (default=-1), shape=[-1]The mean length in time steps of the active buying period. Required for Normal active_buying_frequency_type. Must be greater than or equal to 1
- range:
[1.0, 1e+299]
XML:
<active_buying_mean>[double]</active_buying_mean>
JSON:
{"active_buying_mean": -1} # double
Python:
{"active_buying_mean": -1} # double, optional
- active_buying_stddev:
double, optional (default=-1), shape=[-1]The standard deviation of the length in time steps of the active buying period. Required for Normal active_buying_frequency_type. Must be greater than or equal to 0
- range:
[0.0, 1e+299]
XML:
<active_buying_stddev>[double]</active_buying_stddev>
JSON:
{"active_buying_stddev": -1} # double
Python:
{"active_buying_stddev": -1} # double, optional
- dormant_buying_frequency_type:
std::string, optional (default=”Fixed”), shape=[-1]Options: Fixed, Uniform, Normal. Fixed requires dormant_buying_val. Uniform requires dormant_buying_min and dormant_buying_max. Normal requires dormant_buying_mean and dormant_buying_std, with optional dormant_buying_min and dormant_buying_max.
- categorical:
[‘Fixed’, ‘Uniform’, ‘Normal’]
XML:
<dormant_buying_frequency_type>[string]</dormant_buying_frequency_type>
JSON:
{"dormant_buying_frequency_type": "Fixed"} # string
Python:
{"dormant_buying_frequency_type": 'Fixed'} # string, optional
- dormant_buying_val:
int, optional (default=-1), shape=[-1]The length in time steps of the dormant buying period. Required for fixed dormant_buying_frequency_type. Default is -1, agent has no dormant period and stays active.
- range:
[-1, 1e+299]
XML:
<dormant_buying_val>[int]</dormant_buying_val>
JSON:
{"dormant_buying_val": -1} # int
Python:
{"dormant_buying_val": -1} # int, optional
- dormant_buying_min:
int, optional (default=-1), shape=[-1]The minimum length in time steps of the dormant buying period. Required for Uniform and optional for Normal dormant_buying_frequency_type.
- range:
[0, 1e+299]
XML:
<dormant_buying_min>[int]</dormant_buying_min>
JSON:
{"dormant_buying_min": -1} # int
Python:
{"dormant_buying_min": -1} # int, optional
- dormant_buying_max:
int, optional (default=-1), shape=[-1]The maximum length in time steps of the dormant buying period. Required for Uniform dormant_buying_frequency_type, optional for Normal. Must be greater than or equal to dormant_buying_min
- range:
[0, 1e+299]
XML:
<dormant_buying_max>[int]</dormant_buying_max>
JSON:
{"dormant_buying_max": -1} # int
Python:
{"dormant_buying_max": -1} # int, optional
- dormant_buying_mean:
double, optional (default=-1), shape=[-1]The mean length in time steps of the dormant buying period. Required for Normal dormant_buying_frequency_type. Must be greater than or equal to 0
- range:
[0.0, 1e+299]
XML:
<dormant_buying_mean>[double]</dormant_buying_mean>
JSON:
{"dormant_buying_mean": -1} # double
Python:
{"dormant_buying_mean": -1} # double, optional
- dormant_buying_stddev:
double, optional (default=-1), shape=[-1]The standard deviation of the length in time steps of the dormant buying period. Required for Normal dormant_buying_frequency_type. Must be greater than or equal to 0
- range:
[0.0, 1e+299]
XML:
<dormant_buying_stddev>[double]</dormant_buying_stddev>
JSON:
{"dormant_buying_stddev": -1} # double
Python:
{"dormant_buying_stddev": -1} # double, optional
- buying_size_type:
std::string, optional (default=”Fixed”), shape=[-1]Behavior function used to determine the size of requests made. All values are a fraction of maximum capacity, determined by the throughput and capacity remaining. Options: Fixed, Uniform, Normal. Fixed is default behavior. Uniform requires buying_size_min and buying_size_max. Normal requires buying_size_mean and buying_size_stddev, optional buying_size_min and buying_size_max.
- categorical:
[‘Fixed’, ‘Uniform’, ‘Normal’]
XML:
<buying_size_type>[string]</buying_size_type>
JSON:
{"buying_size_type": "Fixed"} # string
Python:
{"buying_size_type": 'Fixed'} # string, optional
- buying_size_val:
double, optional (default=1.0), shape=[-1]The size of the buy request as a fraction of maximum capacity. Optional for Fixed buying_size_type. Must be greater than or equal to 0.0
- range:
[0.0, 1.0]
XML:
<buying_size_val>[double]</buying_size_val>
JSON:
{"buying_size_val": 1.0} # double
Python:
{"buying_size_val": 1.0} # double, optional
- buying_size_min:
double, optional (default=-1.0), shape=[-1]The minimum size of the buy request as a fraction of maximum capacity. Required for Uniform and optional for Normal buying_size_type. Must be greater than or equal to zero.
- range:
[0.0, 1.0]
XML:
<buying_size_min>[double]</buying_size_min>
JSON:
{"buying_size_min": -1.0} # double
Python:
{"buying_size_min": -1.0} # double, optional
- buying_size_max:
double, optional (default=-1.0), shape=[-1]The maximum size of the buy request as a fraction of maximum capacity. Required for Uniform buying_size_type, optional for Normal. Must be greater than or equal to buying_size_min
- range:
[0.0, 1.0]
XML:
<buying_size_max>[double]</buying_size_max>
JSON:
{"buying_size_max": -1.0} # double
Python:
{"buying_size_max": -1.0} # double, optional
- buying_size_mean:
double, optional (default=-1.0), shape=[-1]The mean size of the buy request as a fraction of maximum capacity. Required for Normal buying_size_type.
- range:
[0.0, 1.0]
XML:
<buying_size_mean>[double]</buying_size_mean>
JSON:
{"buying_size_mean": -1.0} # double
Python:
{"buying_size_mean": -1.0} # double, optional
- buying_size_stddev:
double, optional (default=-1.0), shape=[-1]The standard deviation of the size of the buy request as a fraction of maximum capacity. Required for Normal buying_size_type.
- range:
[0.0, 1.0]
XML:
<buying_size_stddev>[double]</buying_size_stddev>
JSON:
{"buying_size_stddev": -1.0} # double
Python:
{"buying_size_stddev": -1.0} # double, optional
- reorder_point:
double, optional (default=-1), shape=[-1]The point at which the facility will request more material. Above this point, no request will be made. Must be less than max_inv_size.If paired with reorder_quantity, this agent will have an (R,Q) inventory policy. If reorder_point is used alone, this agent will have an (s,S) inventory policy, with S (the maximum) being set at max_inv_size.
XML:
<reorder_point>[double]</reorder_point>
JSON:
{"reorder_point": -1} # double
Python:
{"reorder_point": -1} # double, optional
- reorder_quantity:
double, optional (default=-1), shape=[-1]The amount of material that will be requested when the reorder point is reached. Exclusive request, so will demand exactly reorder_quantity.Reorder_point + reorder_quantity must be less than max_inv_size.
XML:
<reorder_quantity>[double]</reorder_quantity>
JSON:
{"reorder_quantity": -1} # double
Python:
{"reorder_quantity": -1} # double, optional
- cumulative_cap:
double, optional (default=-1), shape=[-1]After receiving this much material cumulatively, the agent will go dormant. Must be paired with dormant_buying_frequency_type and any other dormant parameters. The per-time step demand is unchanged except the cycle cap is almost reached.
XML:
<cumulative_cap>[double]</cumulative_cap>
JSON:
{"cumulative_cap": -1} # double
Python:
{"cumulative_cap": -1} # double, optional
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::Storage
Simulation Entity Type: facility
Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::CommodityProducer’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::CommodityProducer’, ‘cyclus::toolkit::Position’]
XML Input Schema¶
<interleave>
<element name="in_commods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="in_commod_prefs">
<oneOrMore>
<element name="val">
<data type="double"/>
</element>
</oneOrMore>
</element>
</optional>
<element name="out_commods">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="in_recipe">
<data type="string"/>
</element>
</optional>
<optional>
<element name="residence_time">
<data type="int"/>
</element>
</optional>
<optional>
<element name="sell_quantity">
<data type="double"/>
</element>
</optional>
<optional>
<element name="throughput">
<data type="double"/>
</element>
</optional>
<optional>
<element name="max_inv_size">
<data type="double"/>
</element>
</optional>
<optional>
<element name="discrete_handling">
<data type="boolean"/>
</element>
</optional>
<optional>
<element name="active_buying_frequency_type">
<data type="string"/>
</element>
</optional>
<optional>
<element name="active_buying_val">
<data type="int"/>
</element>
</optional>
<optional>
<element name="active_buying_min">
<data type="int"/>
</element>
</optional>
<optional>
<element name="active_buying_max">
<data type="int"/>
</element>
</optional>
<optional>
<element name="active_buying_mean">
<data type="double"/>
</element>
</optional>
<optional>
<element name="active_buying_stddev">
<data type="double"/>
</element>
</optional>
<optional>
<element name="dormant_buying_frequency_type">
<data type="string"/>
</element>
</optional>
<optional>
<element name="dormant_buying_val">
<data type="int"/>
</element>
</optional>
<optional>
<element name="dormant_buying_min">
<data type="int"/>
</element>
</optional>
<optional>
<element name="dormant_buying_max">
<data type="int"/>
</element>
</optional>
<optional>
<element name="dormant_buying_mean">
<data type="double"/>
</element>
</optional>
<optional>
<element name="dormant_buying_stddev">
<data type="double"/>
</element>
</optional>
<optional>
<element name="buying_size_type">
<data type="string"/>
</element>
</optional>
<optional>
<element name="buying_size_val">
<data type="double"/>
</element>
</optional>
<optional>
<element name="buying_size_min">
<data type="double"/>
</element>
</optional>
<optional>
<element name="buying_size_max">
<data type="double"/>
</element>
</optional>
<optional>
<element name="buying_size_mean">
<data type="double"/>
</element>
</optional>
<optional>
<element name="buying_size_stddev">
<data type="double"/>
</element>
</optional>
<optional>
<element name="reorder_point">
<data type="double"/>
</element>
</optional>
<optional>
<element name="reorder_quantity">
<data type="double"/>
</element>
</optional>
<optional>
<element name="cumulative_cap">
<data type="double"/>
</element>
</optional>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:Mixer¶
Mixer mixes N streams with fixed, static, user-specified ratios into a single output stream. The Mixer has N input inventories: one for each streams to be mixed, and one output stream. The supplying of mixed material is constrained by available inventory of mixed material quantities.
State Variables¶
- in_streams:
std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>, shape=[-1, -1, -1, -1, -1, -1, -1, -1]XML:
<in_streams> <stream> <info> <mixing_ratio>[double]</mixing_ratio> <buf_size>[double]</buf_size> </info> <commodities> <item> <commodity>[incommodity]</commodity> <pref>[double]</pref> </item> <item> <commodity>[incommodity]</commodity> <pref>[double]</pref> </item> ... </commodities> </stream> <stream> <info> <mixing_ratio>[double]</mixing_ratio> <buf_size>[double]</buf_size> </info> <commodities> <item> <commodity>[incommodity]</commodity> <pref>[double]</pref> </item> <item> <commodity>[incommodity]</commodity> <pref>[double]</pref> </item> ... </commodities> </stream> ... </in_streams>
JSON:
{"in_streams": {"stream": [ { "info": { "mixing_ratio": "<required>", "buf_size": "<required>" }, "commodities": { "item": [{ "commodity": "<required>", "pref": "<required>"}, {"commodity": "<required>", "pref": "<required>"}, ... ]} }, { "info": { "mixing_ratio": "<required>", "buf_size": "<required>" }, "commodities": { "item": [{ "commodity": "<required>", "pref": "<required>"}, {"commodity": "<required>", "pref": "<required>"}, ... ]} }, ... ]}}
Python:
{"in_streams": {"stream": [ { "info": { "mixing_ratio": 0.0, "buf_size": 0.0 }, "commodities": { "item": [{ "commodity": "", "pref": 0.0}, {"commodity": "", "pref": 0.0}, ... ]} }, { "info": { "mixing_ratio": 0.0, "buf_size": 0.0 }, "commodities": { "item": [{ "commodity": "", "pref": 0.0}, {"commodity": "", "pref": 0.0}, ... ]} }, ... ]}}
- out_commod:
std::string, shape=[-1]Commodity on which to offer/supply mixed fuel material.
XML:
<out_commod>[outcommodity]</out_commod>
JSON:
{"out_commod": "<required>"} # outcommodity
Python:
{"out_commod": ""} # outcommodity, required
- out_buf_size:
double, optional (default=1e+299), shape=[-1]Maximum amount of mixed material that can be stored. If full, the facility halts operation until space becomes available.
- range:
[0.0, 1e+299]
XML:
<out_buf_size>[double ( kg )]</out_buf_size>
JSON:
{"out_buf_size": 1e+299} # double, kg
Python:
{"out_buf_size": 1e+299} # double, kg, optional
- throughput:
double, optional (default=1e+299), shape=[-1]Maximum number of kg of fuel material that can be mixed per time step.
- range:
[0.0, 1e+299]
XML:
<throughput>[double ( kg )]</throughput>
JSON:
{"throughput": 1e+299} # double, kg
Python:
{"throughput": 1e+299} # double, kg, optional
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::Mixer
Simulation Entity Type: facility
Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::Position’]
niche: mixing facility
XML Input Schema¶
<interleave>
<element name="in_streams">
<oneOrMore>
<element name="stream">
<interleave>
<element name="info">
<interleave>
<element name="mixing_ratio">
<data type="double"/>
</element>
<element name="buf_size">
<data type="double"/>
</element>
</interleave>
</element>
<element name="commodities">
<oneOrMore>
<element name="item">
<interleave>
<element name="commodity">
<data type="string"/>
</element>
<element name="pref">
<data type="double"/>
</element>
</interleave>
</element>
</oneOrMore>
</element>
</interleave>
</element>
</oneOrMore>
</element>
<element name="out_commod">
<data type="string"/>
</element>
<optional>
<element name="out_buf_size">
<data type="double"/>
</element>
</optional>
<optional>
<element name="throughput">
<data type="double"/>
</element>
</optional>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:DeployInst¶
Builds and manages agents (facilities) according to a manually specified deployment schedule. Deployed agents are automatically decommissioned at the end of their lifetime. Deployed and decommissioned agents are registered and unregistered with a region. The user specifies a list of prototypes for each and corresponding build times, number to build, and (optionally) lifetimes. The same prototype can be specified multiple times with any combination of the same or different build times, build number, and lifetimes.
State Variables¶
- prototypes:
std::vector<std::string>, shape=[-1, -1]Ordered list of prototypes to build.
XML:
<prototypes> <val>[prototype]</val> <val>[prototype]</val> ... </prototypes>
JSON:
{"prototypes": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"prototypes": {"val": [ "", "", ... ]}}
- build_times:
std::vector<int>, shape=[-1, -1]Time step on which to deploy agents given in prototype list (same order).
XML:
<build_times> <val>[int]</val> <val>[int]</val> ... </build_times>
JSON:
{"build_times": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"build_times": {"val": [ 0, 0, ... ]}}
- n_build:
std::vector<int>, shape=[-1, -1]Number of each prototype given in prototype list that should be deployed (same order).
XML:
<n_build> <val>[int]</val> <val>[int]</val> ... </n_build>
JSON:
{"n_build": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"n_build": {"val": [ 0, 0, ... ]}}
- lifetimes:
std::vector<int>, optional (default=[]), shape=[-1, -1]Lifetimes for each prototype in prototype list (same order). These lifetimes override the lifetimes in the original prototype definition. If unspecified, lifetimes from the original prototype definitions are used. Although a new prototype is created in the Prototypes table for each lifetime with the suffix ‘_life_[lifetime]’, all deployed agents themselves will have the same original prototype name (and so will the Agents tables).
XML:
<lifetimes> <val>[int]</val> <val>[int]</val> ... </lifetimes>
JSON:
{"lifetimes": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"lifetimes": {"val": [ 0, 0, ... ]}}
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::DeployInst
Simulation Entity Type: institution
Interfaces: [‘cyclus::Institution’, ‘cyclus::toolkit::CommodityProducerManager’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Ider’, ‘cyclus::Institution’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::CommodityProducerManager’, ‘cyclus::toolkit::Position’]
XML Input Schema¶
<interleave>
<element name="prototypes">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<element name="build_times">
<oneOrMore>
<element name="val">
<data type="int"/>
</element>
</oneOrMore>
</element>
<element name="n_build">
<oneOrMore>
<element name="val">
<data type="int"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="lifetimes">
<oneOrMore>
<element name="val">
<data type="int"/>
</element>
</oneOrMore>
</element>
</optional>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:ManagerInst¶
An institution that owns and operates a manually entered list of facilities in the input file
State Variables¶
- prototypes:
std::vector<std::string>, shape=[-1, -1]A set of facility prototypes that this institution can build. All prototypes in this list must be based on an archetype that implements the cyclus::toolkit::CommodityProducer interface
XML:
<prototypes> <val>[prototype]</val> <val>[prototype]</val> ... </prototypes>
JSON:
{"prototypes": {"val": [ "<required>", "<required>", ... ]}}
Python:
{"prototypes": {"val": [ "", "", ... ]}}
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::ManagerInst
Simulation Entity Type: institution
Interfaces: [‘cyclus::Institution’, ‘cyclus::toolkit::Builder’, ‘cyclus::toolkit::CommodityProducerManager’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Ider’, ‘cyclus::Institution’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::Builder’, ‘cyclus::toolkit::CommodityProducerManager’, ‘cyclus::toolkit::Position’]
XML Input Schema¶
<interleave>
<element name="prototypes">
<oneOrMore>
<element name="val">
<data type="string"/>
</element>
</oneOrMore>
</element>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
:cycamore:GrowthRegion¶
A region that governs a scenario in which there is growth in demand for a commodity.
State Variables¶
- growth:
std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>, shape=[-1, -1, -1, -1, -1, -1, -1, -1]Nameplate capacity demand functions.
Each demand type must be for a commodity for which capacity can be built (e.g., ‘power’ from cycamore::Reactors). Any archetype that implements the cyclus::toolkit::CommodityProducer interface can interact with the GrowthRegion in the manner.
Demand functions are defined as piecewise functions. Each piece must be provided a starting time and function description. Each function description is comprised of a function type and associated parameters.
Start times are inclusive. For a start time \(t_0\), the demand function is evaluated on \([t_0, \infty)\).
Supported function types are based on the cyclus::toolkit::BasicFunctionFactory types.
The type name is the lower-case name of the function (e.g., ‘linear’, ‘exponential’, etc.).
The parameters associated with each function type can be found on their respective documentation pages.
XML:
<growth> <item> <commod>[string]</commod> <piecewise_function> <piece> <start>[int]</start> <function> <type>[string]</type> <params>[string]</params> </function> </piece> <piece> <start>[int]</start> <function> <type>[string]</type> <params>[string]</params> </function> </piece> ... </piecewise_function> </item> <item> <commod>[string]</commod> <piecewise_function> <piece> <start>[int]</start> <function> <type>[string]</type> <params>[string]</params> </function> </piece> <piece> <start>[int]</start> <function> <type>[string]</type> <params>[string]</params> </function> </piece> ... </piecewise_function> </item> ... </growth>
JSON:
{"growth": { "item": [{ "commod": "<required>", "piecewise_function": {"piece": [ { "start": "<required>", "function": { "type": "<required>", "params": "<required>" } }, { "start": "<required>", "function": { "type": "<required>", "params": "<required>" } }, ... ]}}, {"commod": "<required>", "piecewise_function": {"piece": [ { "start": "<required>", "function": { "type": "<required>", "params": "<required>" } }, { "start": "<required>", "function": { "type": "<required>", "params": "<required>" } }, ... ]}}, ... ]}}
Python:
{"growth": { "item": [{ "commod": "", "piecewise_function": {"piece": [ { "start": 0, "function": { "type": "", "params": "" } }, { "start": 0, "function": { "type": "", "params": "" } }, ... ]}}, {"commod": "", "piecewise_function": {"piece": [ { "start": 0, "function": { "type": "", "params": "" } }, { "start": 0, "function": { "type": "", "params": "" } }, ... ]}}, ... ]}}
- latitude:
double, optional (default=0.0), shape=[-1]Latitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<latitude>[double]</latitude>
JSON:
{"latitude": 0.0} # double
Python:
{"latitude": 0.0} # double, optional
- longitude:
double, optional (default=0.0), shape=[-1]Longitude of the agent’s geographical position. The value should be expressed in degrees as a double.
XML:
<longitude>[double]</longitude>
JSON:
{"longitude": 0.0} # double
Python:
{"longitude": 0.0} # double, optional
Other Info¶
Full Archetype Name: cycamore::GrowthRegion
Simulation Entity Type: region
Interfaces: [‘cyclus::Region’, ‘cyclus::toolkit::Position’]
All Interfaces: [‘cyclus::Agent’, ‘cyclus::Ider’, ‘cyclus::Region’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::toolkit::Position’]
XML Input Schema¶
<interleave>
<element name="growth">
<oneOrMore>
<element name="item">
<interleave>
<element name="commod">
<data type="string"/>
</element>
<element name="piecewise_function">
<oneOrMore>
<element name="piece">
<interleave>
<element name="start">
<data type="int"/>
</element>
<element name="function">
<interleave>
<element name="type">
<data type="string"/>
</element>
<element name="params">
<data type="string"/>
</element>
</interleave>
</element>
</interleave>
</element>
</oneOrMore>
</element>
</interleave>
</element>
</oneOrMore>
</element>
<optional>
<element name="latitude">
<data type="double"/>
</element>
</optional>
<optional>
<element name="longitude">
<data type="double"/>
</element>
</optional>
</interleave>
