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>[recipe]</outrecipe>

JSON:

{"outrecipe": ""}  # recipe

Python:

{"outrecipe": ''}  # recipe, 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

Other Info

  • Full Archetype Name: cycamore::Source
  • Simulation Entity Type: facility
  • Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::CommodityProducer’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::CommodityProducer’]

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>
</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>[recipe]</recipe_name>

JSON:

{"recipe_name": ""}  # recipe

Python:

{"recipe_name": ''}  # recipe, 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

Other Info

  • Full Archetype Name: cycamore::Sink
  • Simulation Entity Type: facility
  • Interfaces: [‘cyclus::Facility’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’]

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>
</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 an 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.

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>[recipe]</feed_recipe>

JSON:

{"feed_recipe": "<required>"}  # recipe

Python:

{"feed_recipe": ""}  # recipe, 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

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

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

Other Info

  • Full Archetype Name: cycamore::Enrichment
  • Simulation Entity Type: facility
  • Interfaces: [‘cyclus::Facility’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’]
  • 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>
</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>[recipe]</val>
  <val>[recipe]</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>[recipe]</val>
  <val>[recipe]</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>[recipe]</val>
  <val>[recipe]</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>[recipe]</val>
  <val>[recipe]</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.

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, shape=[-1]

Number of assemblies that constitute a full core.

XML:

<n_assem_core>[int]</n_assem_core>

JSON:

{"n_assem_core": "<required>"}  # int

Python:

{"n_assem_core": 0}  # int, required
n_assem_fresh:

int, optional (default=0), shape=[-1]

Number of fresh fuel assemblies to keep on-hand if possible.

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.

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, 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": "<required>"}  # int, time steps

Python:

{"cycle_time": 0}  # int, time steps, required
refuel_time:

int, 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": "<required>"}  # int, time steps

Python:

{"refuel_time": 0}  # int, time steps, required
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.

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
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,
   ...
]}}

Other Info

  • Full Archetype Name: cycamore::Reactor
  • Simulation Entity Type: facility
  • Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::CommodityProducer’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::CommodityProducer’]
  • 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>
    <element name="n_assem_core">
        <data type="int"/>
    </element>
    <optional>
        <element name="n_assem_fresh">
            <data type="int"/>
        </element>
    </optional>
    <optional>
        <element name="n_assem_spent">
            <data type="int"/>
        </element>
    </optional>
    <element name="cycle_time">
        <data type="int"/>
    </element>
    <element name="refuel_time">
        <data type="int"/>
    </element>
    <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="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>
</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>[recipe]</feed_recipe>

JSON:

{"feed_recipe": ""}  # recipe

Python:

{"feed_recipe": ''}  # recipe, 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},
          ...
      ]}
      }
    },
    ...
]}}

Other Info

  • Full Archetype Name: cycamore::Separations
  • Simulation Entity Type: facility
  • Interfaces: [‘cyclus::Facility’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’]
  • 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>
</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>[recipe]</fill_recipe>

JSON:

{"fill_recipe": "<required>"}  # recipe

Python:

{"fill_recipe": ""}  # recipe, 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>[recipe]</fiss_recipe>

JSON:

{"fiss_recipe": ""}  # recipe

Python:

{"fiss_recipe": ''}  # recipe, 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>[recipe]</topup_recipe>

JSON:

{"topup_recipe": ""}  # recipe

Python:

{"topup_recipe": ''}  # recipe, 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

Other Info

  • Full Archetype Name: cycamore::FuelFab
  • Simulation Entity Type: facility
  • Interfaces: [‘cyclus::Facility’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’]
  • 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>
</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>[recipe]</in_recipe>

JSON:

{"in_recipe": ""}  # recipe

Python:

{"in_recipe": ''}  # recipe, 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
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

Other Info

  • Full Archetype Name: storage::Storage
  • Simulation Entity Type: facility
  • Interfaces: [‘cyclus::Facility’, ‘cyclus::toolkit::CommodityProducer’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::CommodityProducer’]

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="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>
</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

Other Info

  • Full Archetype Name: cycamore::Mixer
  • Simulation Entity Type: facility
  • Interfaces: [‘cyclus::Facility’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Facility’, ‘cyclus::Ider’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::Trader’]
  • 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>
</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. 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,
   ...
]}}

Other Info

  • Full Archetype Name: cycamore::DeployInst
  • Simulation Entity Type: institution
  • Interfaces: [‘cyclus::Institution’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Ider’, ‘cyclus::Institution’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’]

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>
</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": [
   "",
   "",
   ...
]}}

Other Info

  • Full Archetype Name: cycamore::ManagerInst
  • Simulation Entity Type: institution
  • Interfaces: [‘cyclus::Institution’, ‘cyclus::toolkit::Builder’, ‘cyclus::toolkit::CommodityProducerManager’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Ider’, ‘cyclus::Institution’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’, ‘cyclus::toolkit::AgentManaged’, ‘cyclus::toolkit::Builder’, ‘cyclus::toolkit::CommodityProducerManager’]

XML Input Schema

<interleave>
    <element name="prototypes">
        <oneOrMore>
            <element name="val">
                <data type="string"/>
            </element>
        </oneOrMore>
    </element>
</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": ""
          }
        },
        ...
    ]}},
    ...
]}}

Other Info

  • Full Archetype Name: cycamore::GrowthRegion
  • Simulation Entity Type: region
  • Interfaces: [‘cyclus::Region’]
  • All Interfaces: [‘cyclus::Agent’, ‘cyclus::Ider’, ‘cyclus::Region’, ‘cyclus::StateWrangler’, ‘cyclus::TimeListener’]

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>
</interleave>