Cyclus Archetypes

This is a collection of archetypes found in the agents module that comes with Cyclus itself.

:agents:Source

A minimum implementation source facility that provides a commodity with a given capacity

State Variables

commod:

std::string, shape=[-1]

commodity that the source facility supplies

schematype:token

XML:

<commod>[outcommodity]</commod>

JSON:

{"commod": "<required>"}  # outcommodity

Python:

{"commod": ""}  # outcommodity, required
recipe_name:

std::string, optional (default=””), shape=[-1]

Recipe name for source facility’s commodity.If empty, source supplies material with requested compositions.

schematype:token

XML:

<recipe_name>[recipe]</recipe_name>

JSON:

{"recipe_name": ""}  # recipe

Python:

{"recipe_name": ''}  # recipe, optional
capacity:

double, shape=[-1]

amount of commodity that can be supplied at each time step

XML:

<capacity>[double]</capacity>

JSON:

{"capacity": "<required>"}  # double

Python:

{"capacity": 0.0}  # double, required

Other Info

  • Full Archetype Name: cyclus::Source
  • 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="commod">
        <data type="token"/>
    </element>
    <optional>
        <element name="recipe_name">
            <data type="token"/>
        </element>
    </optional>
    <element name="capacity">
        <data type="double"/>
    </element>
</interleave>

:agents:Sink

A minimum implementation sink facility that accepts specified amounts of commodities from other agents

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

std::string, optional (default=””), shape=[-1]

Name of recipe to request.If empty, sink requests material no particular composition.

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

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

capacity the sink facility can accept at each time step

XML:

<capacity>[double]</capacity>

JSON:

{"capacity": "<required>"}  # double

Python:

{"capacity": 0.0}  # double, required

Other Info

  • Full Archetype Name: cyclus::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="recipe_name">
            <data type="string"/>
        </element>
    </optional>
    <optional>
        <element name="max_inv_size">
            <data type="double"/>
        </element>
    </optional>
    <element name="capacity">
        <data type="double"/>
    </element>
</interleave>

:agents:NullRegion

A region that owns the simulation’s institutions but exhibits null behavior. No parameters are given when using the null region.

Other Info

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

XML Input Schema

<text/>

:agents:NullInst

An instition that owns facilities in the simulation but exhibits null behavior. No parameters are given when using the null institution.

Other Info

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

XML Input Schema

<text/>

:agents:KFacility

A facility designed for integration tests that both provides and consumes commodities. It changes its request and offer amounts based on a power law with respect to time.

State Variables

in_commod:

std::string, shape=[-1]

commodity that the k-facility consumes

schematype:token

XML:

<in_commod>[incommodity]</in_commod>

JSON:

{"in_commod": "<required>"}  # incommodity

Python:

{"in_commod": ""}  # incommodity, required
recipe_name:

std::string, shape=[50]

recipe name for the k-facility’s in-commodity

schematype:token

XML:

<recipe_name>[recipe]</recipe_name>

JSON:

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

Python:

{"recipe_name": ""}  # recipe, required
out_commod:

std::string, shape=[-1]

commodity that the k-facility supplies

schematype:token

XML:

<out_commod>[outcommodity]</out_commod>

JSON:

{"out_commod": "<required>"}  # outcommodity

Python:

{"out_commod": ""}  # outcommodity, required
in_capacity:

double, shape=[-1]

number of commodity units that can be taken at each timestep (infinite capacity can be represented by a very large number)

XML:

<in_capacity>[double]</in_capacity>

JSON:

{"in_capacity": "<required>"}  # double

Python:

{"in_capacity": 0.0}  # double, required
out_capacity:

double, shape=[-1]

number of commodity units that can be supplied at each timestep (infinite capacity can be represented by a very large number)

XML:

<out_capacity>[double]</out_capacity>

JSON:

{"out_capacity": "<required>"}  # double

Python:

{"out_capacity": 0.0}  # double, required
current_capacity:
 

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

number of output commodity units that can be supplied at the current time step (infinite capacity can be represented by a very large number )

XML:

<current_capacity>[double]</current_capacity>

JSON:

{"current_capacity": 0}  # double

Python:

{"current_capacity": 0}  # double, optional
max_inv_size:

double, optional (default=1e+299), shape=[-1]

total maximum inventory size of the k-facility

XML:

<max_inv_size>[double]</max_inv_size>

JSON:

{"max_inv_size": 1e+299}  # double

Python:

{"max_inv_size": 1e+299}  # double, optional
k_factor_in:

double, shape=[-1]

conversion factor that governs the behavior of the k-facility’s input commodity capacity

XML:

<k_factor_in>[double]</k_factor_in>

JSON:

{"k_factor_in": "<required>"}  # double

Python:

{"k_factor_in": 0.0}  # double, required
k_factor_out:

double, shape=[-1]

conversion factor that governs the behavior of the k-facility’s output commodity capacity

XML:

<k_factor_out>[double]</k_factor_out>

JSON:

{"k_factor_out": "<required>"}  # double

Python:

{"k_factor_out": 0.0}  # double, required

Other Info

  • Full Archetype Name: cyclus::KFacility
  • 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_commod">
        <data type="token"/>
    </element>
    <element name="recipe_name">
        <data type="token"/>
    </element>
    <element name="out_commod">
        <data type="token"/>
    </element>
    <element name="in_capacity">
        <data type="double"/>
    </element>
    <element name="out_capacity">
        <data type="double"/>
    </element>
    <optional>
        <element name="current_capacity">
            <data type="double"/>
        </element>
    </optional>
    <optional>
        <element name="max_inv_size">
            <data type="double"/>
        </element>
    </optional>
    <element name="k_factor_in">
        <data type="double"/>
    </element>
    <element name="k_factor_out">
        <data type="double"/>
    </element>
</interleave>

:agents:Predator

A facility that represents predators in the Lotka-Volterra integration tests

State Variables

commod:

std::string, shape=[-1]

commodity that the predator supplies

schematype:token

XML:

<commod>[outcommodity]</commod>

JSON:

{"commod": "<required>"}  # outcommodity

Python:

{"commod": ""}  # outcommodity, required
prey:

std::string, shape=[-1]

prey that the predator hunts

schematype:token

XML:

<prey>[incommodity]</prey>

JSON:

{"prey": "<required>"}  # incommodity

Python:

{"prey": ""}  # incommodity, required
full:

double, optional (default=1), shape=[-1]

how many units of prey a predator consumes until it is satisfied

XML:

<full>[double]</full>

JSON:

{"full": 1}  # double

Python:

{"full": 1}  # double, optional
hunt_freq:

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

how often a predator needs to hunt

XML:

<hunt_freq>[int]</hunt_freq>

JSON:

{"hunt_freq": 1}  # int

Python:

{"hunt_freq": 1}  # int, optional
hunt_cap:

double, optional (default=1), shape=[-1]

how many units of prey a predator can catch during a hunt

XML:

<hunt_cap>[double]</hunt_cap>

JSON:

{"hunt_cap": 1}  # double

Python:

{"hunt_cap": 1}  # double, optional
success:

double, optional (default=1), shape=[-1]

fraction of hunting success on a scale from 0 to 1

XML:

<success>[double]</success>

JSON:

{"success": 1}  # double

Python:

{"success": 1}  # double, optional
consumed:

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

how many units of prey consumed per time step

XML:

<consumed>[double]</consumed>

JSON:

{"consumed": 0}  # double

Python:

{"consumed": 0}  # double, optional
hunt_factor:

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

whether or not to base hunting success on relative predator/prey populations

XML:

<hunt_factor>[boolean]</hunt_factor>

JSON:

{"hunt_factor": 0}  # boolean

Python:

{"hunt_factor": False}  # boolean, optional
age:

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

age of predator at beginning of simulation

XML:

<age>[int]</age>

JSON:

{"age": 0}  # int

Python:

{"age": 0}  # int, optional
lifespan:

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

how long a predator lives

XML:

<lifespan>[int]</lifespan>

JSON:

{"lifespan": 1}  # int

Python:

{"lifespan": 1}  # int, optional
dead:

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

flag for whether predator is currently dead

XML:

<dead>[boolean]</dead>

JSON:

{"dead": 0}  # boolean

Python:

{"dead": False}  # boolean, optional
nchildren:

double, optional (default=1), shape=[-1]

number of predator children born at each birthing instance

XML:

<nchildren>[double]</nchildren>

JSON:

{"nchildren": 1}  # double

Python:

{"nchildren": 1}  # double, optional
birth_and_death:
 

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

whether or not simultaneous birth and death are allowed (i.e., can a facility give birth and die in the same time step?)

XML:

<birth_and_death>[boolean]</birth_and_death>

JSON:

{"birth_and_death": 0}  # boolean

Python:

{"birth_and_death": False}  # boolean, optional

Other Info

  • Full Archetype Name: cyclus::Predator
  • 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="commod">
        <data type="token"/>
    </element>
    <element name="prey">
        <data type="token"/>
    </element>
    <optional>
        <element name="full">
            <data type="double"/>
        </element>
    </optional>
    <optional>
        <element name="hunt_freq">
            <data type="int"/>
        </element>
    </optional>
    <optional>
        <element name="hunt_cap">
            <data type="double"/>
        </element>
    </optional>
    <optional>
        <element name="success">
            <data type="double"/>
        </element>
    </optional>
    <optional>
        <element name="consumed">
            <data type="double"/>
        </element>
    </optional>
    <optional>
        <element name="hunt_factor">
            <data type="boolean"/>
        </element>
    </optional>
    <optional>
        <element name="age">
            <data type="int"/>
        </element>
    </optional>
    <optional>
        <element name="lifespan">
            <data type="int"/>
        </element>
    </optional>
    <optional>
        <element name="dead">
            <data type="boolean"/>
        </element>
    </optional>
    <optional>
        <element name="nchildren">
            <data type="double"/>
        </element>
    </optional>
    <optional>
        <element name="birth_and_death">
            <data type="boolean"/>
        </element>
    </optional>
</interleave>

:agents:Prey

A facility that represents prey in the Lotka-Volterra integration tests

State Variables

commod:

std::string, shape=[-1]

schematype:token

XML:

<commod>[outcommodity]</commod>

JSON:

{"commod": "<required>"}  # outcommodity

Python:

{"commod": ""}  # outcommodity, required
age:

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

age of prey at start of simulation

XML:

<age>[int]</age>

JSON:

{"age": 0}  # int

Python:

{"age": 0}  # int, optional
dead:

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

flag for whether prey is currently dead

XML:

<dead>[boolean]</dead>

JSON:

{"dead": 0}  # boolean

Python:

{"dead": False}  # boolean, optional
nchildren:

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

number of children born at each birthing instance

XML:

<nchildren>[int]</nchildren>

JSON:

{"nchildren": 1}  # int

Python:

{"nchildren": 1}  # int, optional
birth_freq:

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

number of time steps between birth of children

XML:

<birth_freq>[int]</birth_freq>

JSON:

{"birth_freq": 1}  # int

Python:

{"birth_freq": 1}  # int, optional
birth_and_death:
 

bool, optional (default=1), shape=[-1]

whether or not simultaneous birth and death are allowed (i.e., can a facility give birth and die in the same time step?)

XML:

<birth_and_death>[boolean]</birth_and_death>

JSON:

{"birth_and_death": 1}  # boolean

Python:

{"birth_and_death": True}  # boolean, optional

Other Info

  • Full Archetype Name: cyclus::Prey
  • 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="commod">
        <data type="token"/>
    </element>
    <optional>
        <element name="age">
            <data type="int"/>
        </element>
    </optional>
    <optional>
        <element name="dead">
            <data type="boolean"/>
        </element>
    </optional>
    <optional>
        <element name="nchildren">
            <data type="int"/>
        </element>
    </optional>
    <optional>
        <element name="birth_freq">
            <data type="int"/>
        </element>
    </optional>
    <optional>
        <element name="birth_and_death">
            <data type="boolean"/>
        </element>
    </optional>
</interleave>