build/cycamore/reactor.cc

Go to the documentation of this file.

 
#line 1 "/cycamore/src/reactor.cc"
#include "reactor.h"
 
using cyclus::Material;
using cyclus::toolkit::MatVec;
using cyclus::KeyError;
using cyclus::ValueError;
using cyclus::Request;
 
namespace cycamore {
 
Reactor::Reactor(cyclus::Context* ctx)
    : cyclus::Facility(ctx),
      n_assem_batch(0),
      assem_size(0),
      n_assem_core(0),
      n_assem_spent(0),
      n_assem_fresh(0),
      cycle_time(0),
      refuel_time(0),
      cycle_step(0),
      power_cap(0),
      power_name("power"),
      discharged(false),
      keep_packaging(true) {}
cyclus::Agent* Reactor::Clone() {
  cycamore::Reactor* m = new cycamore::Reactor(context());
  m->InitFrom(this);
  return m;
};
#line 25 "/cycamore/src/reactor.cc"
 
std::string Reactor::schema() {
  return ""
    "<interleave>\n"
    "    <optional>\n"
    "        <element name=\"latitude\">\n"
    "            <a:documentation>Latitude of the agent's geographical position. The value should be expressed in degrees as a double.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"longitude\">\n"
    "            <a:documentation>Longitude of the agent's geographical position. The value should be expressed in degrees as a double.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <element name=\"fuel_incommods\">\n"
    "        <oneOrMore>\n"
    "            <element name=\"val\">\n"
    "                <data type=\"string\"/>\n"
    "            </element>\n"
    "        </oneOrMore>\n"
    "    </element>\n"
    "    <element name=\"fuel_inrecipes\">\n"
    "        <oneOrMore>\n"
    "            <element name=\"val\">\n"
    "                <data type=\"string\"/>\n"
    "            </element>\n"
    "        </oneOrMore>\n"
    "    </element>\n"
    "    <optional>\n"
    "        <element name=\"fuel_prefs\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"double\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <element name=\"fuel_outcommods\">\n"
    "        <oneOrMore>\n"
    "            <element name=\"val\">\n"
    "                <data type=\"string\"/>\n"
    "            </element>\n"
    "        </oneOrMore>\n"
    "    </element>\n"
    "    <element name=\"fuel_outrecipes\">\n"
    "        <oneOrMore>\n"
    "            <element name=\"val\">\n"
    "                <data type=\"string\"/>\n"
    "            </element>\n"
    "        </oneOrMore>\n"
    "    </element>\n"
    "    <optional>\n"
    "        <element name=\"recipe_change_times\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"int\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"recipe_change_commods\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"string\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"recipe_change_in\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"string\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"recipe_change_out\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"string\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <element name=\"assem_size\">\n"
    "        <a:documentation>Mass (kg) of a single assembly.</a:documentation>\n"
    "        <data type=\"double\"/>\n"
    "    </element>\n"
    "    <element name=\"n_assem_batch\">\n"
    "        <a:documentation>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``.</a:documentation>\n"
    "        <data type=\"int\"/>\n"
    "    </element>\n"
    "    <optional>\n"
    "        <element name=\"n_assem_core\">\n"
    "            <a:documentation>Number of assemblies that constitute a full core.</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"n_assem_fresh\">\n"
    "            <a:documentation>Number of fresh fuel assemblies to keep on-hand if possible.</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"n_assem_spent\">\n"
    "            <a:documentation>Number of spent fuel assemblies that can be stored on-site before reactor operation stalls.</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"cycle_time\">\n"
    "            <a:documentation>The duration of a full operational cycle (excluding refueling time) in time steps.</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"refuel_time\">\n"
    "            <a:documentation>The duration of a full refueling period - the minimum time between the end of a cycle and the start of the next cycle.</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"cycle_step\">\n"
    "            <a:documentation>Number of time steps since the start of the last cycle. Only set this if you know what you are doing</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"power_cap\">\n"
    "            <a:documentation>Amount of electrical power the facility produces when operating normally.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"power_name\">\n"
    "            <a:documentation>The name of the 'power' commodity used in conjunction with a deployment curve.</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"side_products\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"string\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"side_product_quantity\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"double\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"decom_transmute_all\">\n"
    "            <a:documentation>If true, the archetype transmutes all assemblies upon decommissioning If false, the archetype only transmutes half.</a:documentation>\n"
    "            <data type=\"boolean\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"pref_change_times\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"int\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"pref_change_commods\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"string\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"pref_change_values\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"double\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"keep_packaging\">\n"
    "            <a:documentation>Boolean value about whether to keep packaging. If true, packaging will not be stripped upon acceptance into the reactor. If false, package type will be stripped immediately upon acceptance. Has no effect if the incoming material is not packaged.</a:documentation>\n"
    "            <data type=\"boolean\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "</interleave>\n";
};
#line 26 "/cycamore/src/reactor.cc"
 
Json::Value Reactor::annotations() {
  Json::Value root;
  Json::Reader reader;
  bool parsed_ok = reader.parse(
    "{\"name\":\"cycamore::Reactor\",\"entity\":\"facility\",\"p"
    "arents\":[\"cyclus::Facility\",\"cyclus::toolkit::Comm"
    "odityProducer\",\"cyclus::toolkit::Position\"],\"all_p"
    "arents\":[\"EconomicEntity\",\"cyclus::Agent\",\"cyclus:"
    ":Facility\",\"cyclus::Ider\",\"cyclus::StateWrangler\","
    "\"cyclus::TimeListener\",\"cyclus::Trader\",\"cyclus::t"
    "oolkit::AgentManaged\",\"cyclus::toolkit::CommodityP"
    "roducer\",\"cyclus::toolkit::Position\"],\"vars\":{\"lat"
    "itude\":{\"default\":0.0,\"uilabel\":\"Geographical "
    "latitude in degrees as a double\",\"doc\":\"Latitude "
    "of the agent's geographical position. The value "
    "should be expressed in degrees as a double.\",\"type"
    "\":\"double\",\"index\":0,\"shape\":[-"
    "1],\"alias\":\"latitude\",\"tooltip\":\"latitude\"},\"longi"
    "tude\":{\"default\":0.0,\"uilabel\":\"Geographical "
    "longitude in degrees as a double\",\"doc\":\"Longitude"
    " of the agent's geographical position. The value "
    "should be expressed in degrees as a double.\",\"type"
    "\":\"double\",\"index\":1,\"shape\":[-"
    "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"},\"fue"
    "l_incommods\":{\"uitype\":[\"oneormore\",\"incommodity\"]"
    ",\"uilabel\":[\"Fresh Fuel Commodity "
    "List\",\"\"],\"doc\":\"Ordered list of input commodities"
    " on which to requesting fuel.\",\"type\":[\"std::vecto"
    "r\",\"std::string\"],\"index\":2,\"shape\":[-1,-"
    "1],\"alias\":[\"fuel_incommods\",\"val\"],\"tooltip\":[\"fu"
    "el_incommods\",\"\"]},\"fuel_inrecipes\":{\"uitype\":[\"on"
    "eormore\",\"inrecipe\"],\"uilabel\":[\"Fresh Fuel Recipe"
    " List\",\"\"],\"doc\":\"Fresh fuel recipes to request "
    "for each of the given fuel input commodities (same"
    " order).\",\"type\":[\"std::vector\",\"std::string\"],\"in"
    "dex\":3,\"shape\":[-1,-"
    "1],\"alias\":[\"fuel_inrecipes\",\"val\"],\"tooltip\":[\"fu"
    "el_inrecipes\",\"\"]},\"fuel_prefs\":{\"default\":[],\"uil"
    "abel\":[\"Fresh Fuel Preference List\",\"\"],\"doc\":\"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).\",\"type\":[\"st"
    "d::vector\",\"double\"],\"index\":4,\"shape\":[-1,-"
    "1],\"alias\":[\"fuel_prefs\",\"val\"],\"tooltip\":[\"fuel_p"
    "refs\",\"\"]},\"fuel_outcommods\":{\"uitype\":[\"oneormore"
    "\",\"outcommodity\"],\"uilabel\":[\"Spent Fuel Commodity"
    " List\",\"\"],\"doc\":\"Output commodities on which to "
    "offer spent fuel originally received as each "
    "particular input commodity (same order).\",\"type\":["
    "\"std::vector\",\"std::string\"],\"index\":5,\"shape\":[-"
    "1,-"
    "1],\"alias\":[\"fuel_outcommods\",\"val\"],\"tooltip\":[\"f"
    "uel_outcommods\",\"\"]},\"fuel_outrecipes\":{\"uitype\":["
    "\"oneormore\",\"outrecipe\"],\"uilabel\":[\"Spent Fuel "
    "Recipe List\",\"\"],\"doc\":\"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.\",\"type\":[\""
    "std::vector\",\"std::string\"],\"index\":6,\"shape\":[-"
    "1,-"
    "1],\"alias\":[\"fuel_outrecipes\",\"val\"],\"tooltip\":[\"f"
    "uel_outrecipes\",\"\"]},\"recipe_change_times\":{\"defau"
    "lt\":[],\"uilabel\":[\"Time to Change Fresh/Spent Fuel"
    " Recipe\",\"\"],\"doc\":\"A time step on which to change"
    " the input-output recipe pair for a requested "
    "fresh fuel.\",\"type\":[\"std::vector\",\"int\"],\"index\":"
    "7,\"shape\":[-1,-"
    "1],\"alias\":[\"recipe_change_times\",\"val\"],\"tooltip\""
    ":[\"recipe_change_times\",\"\"]},\"recipe_change_commod"
    "s\":{\"default\":[],\"uilabel\":[\"Commodity for Changed"
    " Fresh/Spent Fuel Recipe\",\"\"],\"doc\":\"The input "
    "commodity indicating fresh fuel for which recipes "
    "will be changed. Same order as and direct "
    "correspondence to the specified recipe change time"
    "s.\",\"uitype\":[\"oneormore\",\"incommodity\"],\"type\":[\""
    "std::vector\",\"std::string\"],\"index\":8,\"shape\":[-"
    "1,-"
    "1],\"alias\":[\"recipe_change_commods\",\"val\"],\"toolti"
    "p\":[\"recipe_change_commods\",\"\"]},\"recipe_change_in"
    "\":{\"default\":[],\"uilabel\":[\"New Recipe for Fresh "
    "Fuel\",\"\"],\"doc\":\"The new input recipe to use for "
    "this recipe change. Same order as and direct "
    "correspondence to the specified recipe change time"
    "s.\",\"uitype\":[\"oneormore\",\"inrecipe\"],\"type\":[\"std"
    "::vector\",\"std::string\"],\"index\":9,\"shape\":[-1,-"
    "1],\"alias\":[\"recipe_change_in\",\"val\"],\"tooltip\":[\""
    "recipe_change_in\",\"\"]},\"recipe_change_out\":{\"defau"
    "lt\":[],\"uilabel\":[\"New Recipe for Spent "
    "Fuel\",\"\"],\"doc\":\"The new output recipe to use for "
    "this recipe change. Same order as and direct "
    "correspondence to the specified recipe change time"
    "s.\",\"uitype\":[\"oneormore\",\"outrecipe\"],\"type\":[\"st"
    "d::vector\",\"std::string\"],\"index\":10,\"shape\":[-1,-"
    "1],\"alias\":[\"recipe_change_out\",\"val\"],\"tooltip\":["
    "\"recipe_change_out\",\"\"]},\"assem_size\":{\"doc\":\"Mass"
    " (kg) of a single assembly.\",\"uilabel\":\"Assembly M"
    "ass\",\"uitype\":\"range\",\"range\":[1.0,100000.0],\"unit"
    "s\":\"kg\",\"type\":\"double\",\"index\":11,\"shape\":[-"
    "1],\"alias\":\"assem_size\",\"tooltip\":\"assem_size\"},\"n"
    "_assem_batch\":{\"uilabel\":\"Number of Assemblies per"
    " Batch\",\"doc\":\"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``.\",\"type\":\"int\",\"i"
    "ndex\":12,\"shape\":[-"
    "1],\"alias\":\"n_assem_batch\",\"tooltip\":\"n_assem_batc"
    "h\"},\"n_assem_core\":{\"default\":3,\"uilabel\":\"Number "
    "of Assemblies in "
    "Core\",\"uitype\":\"range\",\"range\":[1,3],\"doc\":\"Number"
    " of assemblies that constitute a full core.\",\"type"
    "\":\"int\",\"index\":13,\"shape\":[-"
    "1],\"alias\":\"n_assem_core\",\"tooltip\":\"n_assem_core\""
    "},\"n_assem_fresh\":{\"default\":0,\"uilabel\":\"Minimum "
    "Fresh Fuel Inventory\",\"uitype\":\"range\",\"range\":[0,"
    "3],\"units\":\"assemblies\",\"doc\":\"Number of fresh "
    "fuel assemblies to keep on-hand if possible.\",\"typ"
    "e\":\"int\",\"index\":14,\"shape\":[-"
    "1],\"alias\":\"n_assem_fresh\",\"tooltip\":\"n_assem_fres"
    "h\"},\"n_assem_spent\":{\"default\":1000000000,\"uilabel"
    "\":\"Maximum Spent Fuel Inventory\",\"uitype\":\"range\","
    "\"range\":[0,1000000000],\"units\":\"assemblies\",\"doc\":"
    "\"Number of spent fuel assemblies that can be "
    "stored on-site before reactor operation stalls.\",\""
    "type\":\"int\",\"index\":15,\"shape\":[-"
    "1],\"alias\":\"n_assem_spent\",\"tooltip\":\"n_assem_spen"
    "t\"},\"cycle_time\":{\"default\":18,\"doc\":\"The duration"
    " of a full operational cycle (excluding refueling "
    "time) in time steps.\",\"uilabel\":\"Cycle "
    "Length\",\"units\":\"time steps\",\"type\":\"int\",\"index\":"
    "16,\"shape\":[-"
    "1],\"alias\":\"cycle_time\",\"tooltip\":\"cycle_time\"},\"r"
    "efuel_time\":{\"default\":1,\"doc\":\"The duration of a "
    "full refueling period - the minimum time between "
    "the end of a cycle and the start of the next "
    "cycle.\",\"uilabel\":\"Refueling Outage "
    "Duration\",\"units\":\"time steps\",\"type\":\"int\",\"index"
    "\":17,\"shape\":[-"
    "1],\"alias\":\"refuel_time\",\"tooltip\":\"refuel_time\"},"
    "\"cycle_step\":{\"default\":0,\"doc\":\"Number of time "
    "steps since the start of the last cycle. Only set "
    "this if you know what you are "
    "doing\",\"uilabel\":\"Time Since Start of Last "
    "Cycle\",\"units\":\"time steps\",\"type\":\"int\",\"index\":1"
    "8,\"shape\":[-"
    "1],\"alias\":\"cycle_step\",\"tooltip\":\"cycle_step\"},\"p"
    "ower_cap\":{\"default\":0,\"doc\":\"Amount of electrical"
    " power the facility produces when operating "
    "normally.\",\"uilabel\":\"Nominal Reactor Power\",\"uity"
    "pe\":\"range\",\"range\":[0.0,2000.0],\"units\":\"MWe\",\"ty"
    "pe\":\"double\",\"index\":19,\"shape\":[-"
    "1],\"alias\":\"power_cap\",\"tooltip\":\"power_cap\"},\"pow"
    "er_name\":{\"default\":\"power\",\"uilabel\":\"Power "
    "Commodity Name\",\"doc\":\"The name of the 'power' "
    "commodity used in conjunction with a deployment cu"
    "rve.\",\"type\":\"std::string\",\"index\":20,\"shape\":[-"
    "1],\"alias\":\"power_name\",\"tooltip\":\"power_name\"},\"s"
    "ide_products\":{\"uilabel\":[\"Side Product from "
    "Reactor Plant\",\"\"],\"default\":[],\"doc\":\"Ordered "
    "vector of side product the reactor produces with p"
    "ower\",\"type\":[\"std::vector\",\"std::string\"],\"index\""
    ":21,\"shape\":[-1,-"
    "1],\"alias\":[\"side_products\",\"val\"],\"tooltip\":[\"sid"
    "e_products\",\"\"]},\"side_product_quantity\":{\"uilabel"
    "\":[\"Quantity of Side Product from Reactor "
    "Plant\",\"\"],\"default\":[],\"doc\":\"Ordered vector of "
    "the quantity of side product the reactor produces "
    "with power\",\"type\":[\"std::vector\",\"double\"],\"index"
    "\":22,\"shape\":[-1,-"
    "1],\"alias\":[\"side_product_quantity\",\"val\"],\"toolti"
    "p\":[\"side_product_quantity\",\"\"]},\"hybrid_\":{\"defau"
    "lt\":1,\"internal\":true,\"doc\":\"True if reactor is a "
    "hybrid system (produces side products)\",\"type\":\"bo"
    "ol\",\"index\":23,\"shape\":[-"
    "1],\"alias\":\"hybrid_\",\"tooltip\":\"hybrid_\",\"uilabel\""
    ":\"hybrid_\"},\"decom_transmute_all\":{\"default\":0,\"ui"
    "label\":\"Boolean for transmutation behavior upon "
    "decommissioning.\",\"doc\":\"If true, the archetype "
    "transmutes all assemblies upon decommissioning If "
    "false, the archetype only transmutes half.\",\"type\""
    ":\"bool\",\"index\":24,\"shape\":[-"
    "1],\"alias\":\"decom_transmute_all\",\"tooltip\":\"decom_"
    "transmute_all\"},\"pref_change_times\":{\"default\":[],"
    "\"uilabel\":[\"Time to Change Fresh Fuel "
    "Preference\",\"\"],\"doc\":\"A time step on which to "
    "change the request preference for a particular "
    "fresh fuel type.\",\"type\":[\"std::vector\",\"int\"],\"in"
    "dex\":25,\"shape\":[-1,-"
    "1],\"alias\":[\"pref_change_times\",\"val\"],\"tooltip\":["
    "\"pref_change_times\",\"\"]},\"pref_change_commods\":{\"d"
    "efault\":[],\"doc\":\"The input commodity for a "
    "particular fuel preference change.  Same order as "
    "and direct correspondence to the specified "
    "preference change times.\",\"uilabel\":[\"Commodity "
    "for Changed Fresh Fuel Preference\",\"\"],\"uitype\":[\""
    "oneormore\",\"incommodity\"],\"type\":[\"std::vector\",\"s"
    "td::string\"],\"index\":26,\"shape\":[-1,-"
    "1],\"alias\":[\"pref_change_commods\",\"val\"],\"tooltip\""
    ":[\"pref_change_commods\",\"\"]},\"pref_change_values\":"
    "{\"default\":[],\"uilabel\":[\"Changed Fresh Fuel "
    "Preference\",\"\"],\"doc\":\"The new/changed request "
    "preference for a particular fresh fuel. Same order"
    " as and direct correspondence to the specified "
    "preference change times.\",\"type\":[\"std::vector\",\"d"
    "ouble\"],\"index\":27,\"shape\":[-1,-"
    "1],\"alias\":[\"pref_change_values\",\"val\"],\"tooltip\":"
    "[\"pref_change_values\",\"\"]},\"keep_packaging\":{\"defa"
    "ult\":true,\"tooltip\":\"Whether to persist packaging "
    "throughout the reactor\",\"doc\":\"Boolean value about"
    " whether to keep packaging. If true, packaging "
    "will not be stripped upon acceptance into the "
    "reactor. If false, package type will be stripped "
    "immediately upon acceptance. Has no effect if the "
    "incoming material is not "
    "packaged.\",\"uilabel\":\"Keep Packaging\",\"uitype\":\"bo"
    "ol\",\"type\":\"bool\",\"index\":28,\"shape\":[-"
    "1],\"alias\":\"keep_packaging\"},\"fresh\":{\"capacity\":\""
    "n_assem_fresh * assem_size\",\"type\":[\"cyclus::toolk"
    "it::ResBuf\",\"cyclus::Material\"],\"index\":29,\"shape\""
    ":[-1,-1]},\"core\":{\"capacity\":\"n_assem_core * assem"
    "_size\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::"
    "Material\"],\"index\":30,\"shape\":[-1,-"
    "1]},\"spent\":{\"capacity\":\"n_assem_spent * assem_siz"
    "e\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::Mate"
    "rial\"],\"index\":31,\"shape\":[-1,-"
    "1]},\"discharged\":{\"default\":0,\"doc\":\"This should "
    "NEVER be set manually\",\"internal\":true,\"type\":\"boo"
    "l\",\"index\":32,\"shape\":[-"
    "1],\"alias\":\"discharged\",\"tooltip\":\"discharged\",\"ui"
    "label\":\"discharged\"},\"res_indexes\":{\"default\":{},\""
    "doc\":\"This should NEVER be set manually\",\"internal"
    "\":true,\"type\":[\"std::map\",\"int\",\"int\"],\"index\":33,"
    "\"shape\":[-1,-1,-"
    "1],\"alias\":[[\"res_indexes\",\"item\"],\"key\",\"val\"],\"t"
    "ooltip\":[[\"res_indexes\",\"\"],\"\",\"\"],\"uilabel\":[[\"re"
    "s_indexes\",\"\"],\"\",\"\"]}},\"niche\":\"reactor\",\"doc\":\"R"
    "eactor 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.\\n\\nEach 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.\\n\\nThe 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.\\n\\nIn 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.\\n\\nWhen 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.\"}", root);
  if (!parsed_ok) {
    throw cyclus::ValueError("failed to parse annotations for cycamore::Reactor.");
  }
  return root;
};
#line 28 "/cycamore/src/reactor.cc"
 
void Reactor::InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
  cyclus::Facility::InfileToDb(tree, di);
  int rawcycpp_shape_latitude[1] = {-1};
  cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
  int rawcycpp_shape_longitude[1] = {-1};
  cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
  int rawcycpp_shape_fuel_incommods[2] = {-1, -1};
  cycpp_shape_fuel_incommods = std::vector<int>(rawcycpp_shape_fuel_incommods, rawcycpp_shape_fuel_incommods + 2);
  int rawcycpp_shape_fuel_inrecipes[2] = {-1, -1};
  cycpp_shape_fuel_inrecipes = std::vector<int>(rawcycpp_shape_fuel_inrecipes, rawcycpp_shape_fuel_inrecipes + 2);
  int rawcycpp_shape_fuel_prefs[2] = {-1, -1};
  cycpp_shape_fuel_prefs = std::vector<int>(rawcycpp_shape_fuel_prefs, rawcycpp_shape_fuel_prefs + 2);
  int rawcycpp_shape_fuel_outcommods[2] = {-1, -1};
  cycpp_shape_fuel_outcommods = std::vector<int>(rawcycpp_shape_fuel_outcommods, rawcycpp_shape_fuel_outcommods + 2);
  int rawcycpp_shape_fuel_outrecipes[2] = {-1, -1};
  cycpp_shape_fuel_outrecipes = std::vector<int>(rawcycpp_shape_fuel_outrecipes, rawcycpp_shape_fuel_outrecipes + 2);
  int rawcycpp_shape_recipe_change_times[2] = {-1, -1};
  cycpp_shape_recipe_change_times = std::vector<int>(rawcycpp_shape_recipe_change_times, rawcycpp_shape_recipe_change_times + 2);
  int rawcycpp_shape_recipe_change_commods[2] = {-1, -1};
  cycpp_shape_recipe_change_commods = std::vector<int>(rawcycpp_shape_recipe_change_commods, rawcycpp_shape_recipe_change_commods + 2);
  int rawcycpp_shape_recipe_change_in[2] = {-1, -1};
  cycpp_shape_recipe_change_in = std::vector<int>(rawcycpp_shape_recipe_change_in, rawcycpp_shape_recipe_change_in + 2);
  int rawcycpp_shape_recipe_change_out[2] = {-1, -1};
  cycpp_shape_recipe_change_out = std::vector<int>(rawcycpp_shape_recipe_change_out, rawcycpp_shape_recipe_change_out + 2);
  int rawcycpp_shape_assem_size[1] = {-1};
  cycpp_shape_assem_size = std::vector<int>(rawcycpp_shape_assem_size, rawcycpp_shape_assem_size + 1);
  int rawcycpp_shape_n_assem_batch[1] = {-1};
  cycpp_shape_n_assem_batch = std::vector<int>(rawcycpp_shape_n_assem_batch, rawcycpp_shape_n_assem_batch + 1);
  int rawcycpp_shape_n_assem_core[1] = {-1};
  cycpp_shape_n_assem_core = std::vector<int>(rawcycpp_shape_n_assem_core, rawcycpp_shape_n_assem_core + 1);
  int rawcycpp_shape_n_assem_fresh[1] = {-1};
  cycpp_shape_n_assem_fresh = std::vector<int>(rawcycpp_shape_n_assem_fresh, rawcycpp_shape_n_assem_fresh + 1);
  int rawcycpp_shape_n_assem_spent[1] = {-1};
  cycpp_shape_n_assem_spent = std::vector<int>(rawcycpp_shape_n_assem_spent, rawcycpp_shape_n_assem_spent + 1);
  int rawcycpp_shape_cycle_time[1] = {-1};
  cycpp_shape_cycle_time = std::vector<int>(rawcycpp_shape_cycle_time, rawcycpp_shape_cycle_time + 1);
  int rawcycpp_shape_refuel_time[1] = {-1};
  cycpp_shape_refuel_time = std::vector<int>(rawcycpp_shape_refuel_time, rawcycpp_shape_refuel_time + 1);
  int rawcycpp_shape_cycle_step[1] = {-1};
  cycpp_shape_cycle_step = std::vector<int>(rawcycpp_shape_cycle_step, rawcycpp_shape_cycle_step + 1);
  int rawcycpp_shape_power_cap[1] = {-1};
  cycpp_shape_power_cap = std::vector<int>(rawcycpp_shape_power_cap, rawcycpp_shape_power_cap + 1);
  int rawcycpp_shape_power_name[1] = {-1};
  cycpp_shape_power_name = std::vector<int>(rawcycpp_shape_power_name, rawcycpp_shape_power_name + 1);
  int rawcycpp_shape_side_products[2] = {-1, -1};
  cycpp_shape_side_products = std::vector<int>(rawcycpp_shape_side_products, rawcycpp_shape_side_products + 2);
  int rawcycpp_shape_side_product_quantity[2] = {-1, -1};
  cycpp_shape_side_product_quantity = std::vector<int>(rawcycpp_shape_side_product_quantity, rawcycpp_shape_side_product_quantity + 2);
  int rawcycpp_shape_hybrid_[1] = {-1};
  cycpp_shape_hybrid_ = std::vector<int>(rawcycpp_shape_hybrid_, rawcycpp_shape_hybrid_ + 1);
  int rawcycpp_shape_decom_transmute_all[1] = {-1};
  cycpp_shape_decom_transmute_all = std::vector<int>(rawcycpp_shape_decom_transmute_all, rawcycpp_shape_decom_transmute_all + 1);
  int rawcycpp_shape_pref_change_times[2] = {-1, -1};
  cycpp_shape_pref_change_times = std::vector<int>(rawcycpp_shape_pref_change_times, rawcycpp_shape_pref_change_times + 2);
  int rawcycpp_shape_pref_change_commods[2] = {-1, -1};
  cycpp_shape_pref_change_commods = std::vector<int>(rawcycpp_shape_pref_change_commods, rawcycpp_shape_pref_change_commods + 2);
  int rawcycpp_shape_pref_change_values[2] = {-1, -1};
  cycpp_shape_pref_change_values = std::vector<int>(rawcycpp_shape_pref_change_values, rawcycpp_shape_pref_change_values + 2);
  int rawcycpp_shape_keep_packaging[1] = {-1};
  cycpp_shape_keep_packaging = std::vector<int>(rawcycpp_shape_keep_packaging, rawcycpp_shape_keep_packaging + 1);
  int rawcycpp_shape_fresh[2] = {-1, -1};
  cycpp_shape_fresh = std::vector<int>(rawcycpp_shape_fresh, rawcycpp_shape_fresh + 2);
  int rawcycpp_shape_core[2] = {-1, -1};
  cycpp_shape_core = std::vector<int>(rawcycpp_shape_core, rawcycpp_shape_core + 2);
  int rawcycpp_shape_spent[2] = {-1, -1};
  cycpp_shape_spent = std::vector<int>(rawcycpp_shape_spent, rawcycpp_shape_spent + 2);
  int rawcycpp_shape_discharged[1] = {-1};
  cycpp_shape_discharged = std::vector<int>(rawcycpp_shape_discharged, rawcycpp_shape_discharged + 1);
  int rawcycpp_shape_res_indexes[3] = {-1, -1, -1};
  cycpp_shape_res_indexes = std::vector<int>(rawcycpp_shape_res_indexes, rawcycpp_shape_res_indexes + 3);
  cyclus::InfileTree* sub = tree->SubTree("config/*");
  int i;
  int n;
  if (sub->NMatches("latitude") > 0) {
    {
      double latitude_val = cyclus::Query<double>(sub, "latitude");
      latitude = latitude_val;
    }
  } else {
    double latitude_tmp = 0.0;
    latitude = latitude_tmp;
  }
  if (sub->NMatches("longitude") > 0) {
    {
      double longitude_val = cyclus::Query<double>(sub, "longitude");
      longitude = longitude_val;
    }
  } else {
    double longitude_tmp = 0.0;
    longitude = longitude_tmp;
  }
  {
    cyclus::InfileTree* bub = sub->SubTree("fuel_incommods", 0);
    cyclus::InfileTree* sub = bub;
    int n1 = sub->NMatches("val");
    std::vector< std::string > fuel_incommods_val;
    fuel_incommods_val.resize(n1);
    for (int i1 = 0; i1 < n1; ++i1) {
      std::string elem;
      {
        std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
        elem = elem_in;
      }
      fuel_incommods_val[i1] = elem;
    }
    fuel_incommods = fuel_incommods_val;
  }
  {
    cyclus::InfileTree* bub = sub->SubTree("fuel_inrecipes", 0);
    cyclus::InfileTree* sub = bub;
    int n1 = sub->NMatches("val");
    std::vector< std::string > fuel_inrecipes_val;
    fuel_inrecipes_val.resize(n1);
    for (int i1 = 0; i1 < n1; ++i1) {
      std::string elem;
      {
        std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
        elem = elem_in;
      }
      fuel_inrecipes_val[i1] = elem;
    }
    fuel_inrecipes = fuel_inrecipes_val;
  }
  if (sub->NMatches("fuel_prefs") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("fuel_prefs", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< double > fuel_prefs_val;
      fuel_prefs_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        double elem;
        {
          double elem_in = cyclus::Query<double>(sub, "val", i1);
          elem = elem_in;
        }
        fuel_prefs_val[i1] = elem;
      }
      fuel_prefs = fuel_prefs_val;
    }
  } else {
    std::vector< double > fuel_prefs_tmp;
    fuel_prefs_tmp.resize(0);
    {
    }
    fuel_prefs = fuel_prefs_tmp;
  }
  {
    cyclus::InfileTree* bub = sub->SubTree("fuel_outcommods", 0);
    cyclus::InfileTree* sub = bub;
    int n1 = sub->NMatches("val");
    std::vector< std::string > fuel_outcommods_val;
    fuel_outcommods_val.resize(n1);
    for (int i1 = 0; i1 < n1; ++i1) {
      std::string elem;
      {
        std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
        elem = elem_in;
      }
      fuel_outcommods_val[i1] = elem;
    }
    fuel_outcommods = fuel_outcommods_val;
  }
  {
    cyclus::InfileTree* bub = sub->SubTree("fuel_outrecipes", 0);
    cyclus::InfileTree* sub = bub;
    int n1 = sub->NMatches("val");
    std::vector< std::string > fuel_outrecipes_val;
    fuel_outrecipes_val.resize(n1);
    for (int i1 = 0; i1 < n1; ++i1) {
      std::string elem;
      {
        std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
        elem = elem_in;
      }
      fuel_outrecipes_val[i1] = elem;
    }
    fuel_outrecipes = fuel_outrecipes_val;
  }
  if (sub->NMatches("recipe_change_times") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("recipe_change_times", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< int > recipe_change_times_val;
      recipe_change_times_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        int elem;
        {
          int elem_in = cyclus::Query<int>(sub, "val", i1);
          elem = elem_in;
        }
        recipe_change_times_val[i1] = elem;
      }
      recipe_change_times = recipe_change_times_val;
    }
  } else {
    std::vector< int > recipe_change_times_tmp;
    recipe_change_times_tmp.resize(0);
    {
    }
    recipe_change_times = recipe_change_times_tmp;
  }
  if (sub->NMatches("recipe_change_commods") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("recipe_change_commods", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > recipe_change_commods_val;
      recipe_change_commods_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string elem;
        {
          std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
          elem = elem_in;
        }
        recipe_change_commods_val[i1] = elem;
      }
      recipe_change_commods = recipe_change_commods_val;
    }
  } else {
    std::vector< std::string > recipe_change_commods_tmp;
    recipe_change_commods_tmp.resize(0);
    {
    }
    recipe_change_commods = recipe_change_commods_tmp;
  }
  if (sub->NMatches("recipe_change_in") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("recipe_change_in", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > recipe_change_in_val;
      recipe_change_in_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string elem;
        {
          std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
          elem = elem_in;
        }
        recipe_change_in_val[i1] = elem;
      }
      recipe_change_in = recipe_change_in_val;
    }
  } else {
    std::vector< std::string > recipe_change_in_tmp;
    recipe_change_in_tmp.resize(0);
    {
    }
    recipe_change_in = recipe_change_in_tmp;
  }
  if (sub->NMatches("recipe_change_out") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("recipe_change_out", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > recipe_change_out_val;
      recipe_change_out_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string elem;
        {
          std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
          elem = elem_in;
        }
        recipe_change_out_val[i1] = elem;
      }
      recipe_change_out = recipe_change_out_val;
    }
  } else {
    std::vector< std::string > recipe_change_out_tmp;
    recipe_change_out_tmp.resize(0);
    {
    }
    recipe_change_out = recipe_change_out_tmp;
  }
  {
    double assem_size_val = cyclus::Query<double>(sub, "assem_size");
    assem_size = assem_size_val;
  }
  {
    int n_assem_batch_val = cyclus::Query<int>(sub, "n_assem_batch");
    n_assem_batch = n_assem_batch_val;
  }
  if (sub->NMatches("n_assem_core") > 0) {
    {
      int n_assem_core_val = cyclus::Query<int>(sub, "n_assem_core");
      n_assem_core = n_assem_core_val;
    }
  } else {
    int n_assem_core_tmp = 3;
    n_assem_core = n_assem_core_tmp;
  }
  if (sub->NMatches("n_assem_fresh") > 0) {
    {
      int n_assem_fresh_val = cyclus::Query<int>(sub, "n_assem_fresh");
      n_assem_fresh = n_assem_fresh_val;
    }
  } else {
    int n_assem_fresh_tmp = 0;
    n_assem_fresh = n_assem_fresh_tmp;
  }
  if (sub->NMatches("n_assem_spent") > 0) {
    {
      int n_assem_spent_val = cyclus::Query<int>(sub, "n_assem_spent");
      n_assem_spent = n_assem_spent_val;
    }
  } else {
    int n_assem_spent_tmp = 1000000000;
    n_assem_spent = n_assem_spent_tmp;
  }
  if (sub->NMatches("cycle_time") > 0) {
    {
      int cycle_time_val = cyclus::Query<int>(sub, "cycle_time");
      cycle_time = cycle_time_val;
    }
  } else {
    int cycle_time_tmp = 18;
    cycle_time = cycle_time_tmp;
  }
  if (sub->NMatches("refuel_time") > 0) {
    {
      int refuel_time_val = cyclus::Query<int>(sub, "refuel_time");
      refuel_time = refuel_time_val;
    }
  } else {
    int refuel_time_tmp = 1;
    refuel_time = refuel_time_tmp;
  }
  if (sub->NMatches("cycle_step") > 0) {
    {
      int cycle_step_val = cyclus::Query<int>(sub, "cycle_step");
      cycle_step = cycle_step_val;
    }
  } else {
    int cycle_step_tmp = 0;
    cycle_step = cycle_step_tmp;
  }
  if (sub->NMatches("power_cap") > 0) {
    {
      double power_cap_val = cyclus::Query<double>(sub, "power_cap");
      power_cap = power_cap_val;
    }
  } else {
    double power_cap_tmp = 0;
    power_cap = power_cap_tmp;
  }
  if (sub->NMatches("power_name") > 0) {
    {
      std::string power_name_val = cyclus::Query<std::string>(sub, "power_name");
      power_name = power_name_val;
    }
  } else {
    std::string power_name_tmp("power");
    power_name = power_name_tmp;
  }
  if (sub->NMatches("side_products") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("side_products", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > side_products_val;
      side_products_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string elem;
        {
          std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
          elem = elem_in;
        }
        side_products_val[i1] = elem;
      }
      side_products = side_products_val;
    }
  } else {
    std::vector< std::string > side_products_tmp;
    side_products_tmp.resize(0);
    {
    }
    side_products = side_products_tmp;
  }
  if (sub->NMatches("side_product_quantity") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("side_product_quantity", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< double > side_product_quantity_val;
      side_product_quantity_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        double elem;
        {
          double elem_in = cyclus::Query<double>(sub, "val", i1);
          elem = elem_in;
        }
        side_product_quantity_val[i1] = elem;
      }
      side_product_quantity = side_product_quantity_val;
    }
  } else {
    std::vector< double > side_product_quantity_tmp;
    side_product_quantity_tmp.resize(0);
    {
    }
    side_product_quantity = side_product_quantity_tmp;
  }
  bool hybrid__tmp = true;
  hybrid_ = hybrid__tmp;
  if (sub->NMatches("decom_transmute_all") > 0) {
    {
      bool decom_transmute_all_val = cyclus::Query<bool>(sub, "decom_transmute_all");
      decom_transmute_all = decom_transmute_all_val;
    }
  } else {
    bool decom_transmute_all_tmp = false;
    decom_transmute_all = decom_transmute_all_tmp;
  }
  if (sub->NMatches("pref_change_times") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("pref_change_times", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< int > pref_change_times_val;
      pref_change_times_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        int elem;
        {
          int elem_in = cyclus::Query<int>(sub, "val", i1);
          elem = elem_in;
        }
        pref_change_times_val[i1] = elem;
      }
      pref_change_times = pref_change_times_val;
    }
  } else {
    std::vector< int > pref_change_times_tmp;
    pref_change_times_tmp.resize(0);
    {
    }
    pref_change_times = pref_change_times_tmp;
  }
  if (sub->NMatches("pref_change_commods") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("pref_change_commods", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > pref_change_commods_val;
      pref_change_commods_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string elem;
        {
          std::string elem_in = cyclus::Query<std::string>(sub, "val", i1);
          elem = elem_in;
        }
        pref_change_commods_val[i1] = elem;
      }
      pref_change_commods = pref_change_commods_val;
    }
  } else {
    std::vector< std::string > pref_change_commods_tmp;
    pref_change_commods_tmp.resize(0);
    {
    }
    pref_change_commods = pref_change_commods_tmp;
  }
  if (sub->NMatches("pref_change_values") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("pref_change_values", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< double > pref_change_values_val;
      pref_change_values_val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        double elem;
        {
          double elem_in = cyclus::Query<double>(sub, "val", i1);
          elem = elem_in;
        }
        pref_change_values_val[i1] = elem;
      }
      pref_change_values = pref_change_values_val;
    }
  } else {
    std::vector< double > pref_change_values_tmp;
    pref_change_values_tmp.resize(0);
    {
    }
    pref_change_values = pref_change_values_tmp;
  }
  if (sub->NMatches("keep_packaging") > 0) {
    {
      bool keep_packaging_val = cyclus::Query<bool>(sub, "keep_packaging");
      keep_packaging = keep_packaging_val;
    }
  } else {
    bool keep_packaging_tmp = true;
    keep_packaging = keep_packaging_tmp;
  }
  bool discharged_tmp = false;
  discharged = discharged_tmp;
  std::map< int, int > res_indexes_tmp;
  {
  }
  res_indexes = res_indexes_tmp;
  di.NewDatum("Info")
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->AddVal("fuel_incommods", fuel_incommods, &cycpp_shape_fuel_incommods)
  ->AddVal("fuel_inrecipes", fuel_inrecipes, &cycpp_shape_fuel_inrecipes)
  ->AddVal("fuel_prefs", fuel_prefs, &cycpp_shape_fuel_prefs)
  ->AddVal("fuel_outcommods", fuel_outcommods, &cycpp_shape_fuel_outcommods)
  ->AddVal("fuel_outrecipes", fuel_outrecipes, &cycpp_shape_fuel_outrecipes)
  ->AddVal("recipe_change_times", recipe_change_times, &cycpp_shape_recipe_change_times)
  ->AddVal("recipe_change_commods", recipe_change_commods, &cycpp_shape_recipe_change_commods)
  ->AddVal("recipe_change_in", recipe_change_in, &cycpp_shape_recipe_change_in)
  ->AddVal("recipe_change_out", recipe_change_out, &cycpp_shape_recipe_change_out)
  ->AddVal("assem_size", assem_size, &cycpp_shape_assem_size)
  ->AddVal("n_assem_batch", n_assem_batch, &cycpp_shape_n_assem_batch)
  ->AddVal("n_assem_core", n_assem_core, &cycpp_shape_n_assem_core)
  ->AddVal("n_assem_fresh", n_assem_fresh, &cycpp_shape_n_assem_fresh)
  ->AddVal("n_assem_spent", n_assem_spent, &cycpp_shape_n_assem_spent)
  ->AddVal("cycle_time", cycle_time, &cycpp_shape_cycle_time)
  ->AddVal("refuel_time", refuel_time, &cycpp_shape_refuel_time)
  ->AddVal("cycle_step", cycle_step, &cycpp_shape_cycle_step)
  ->AddVal("power_cap", power_cap, &cycpp_shape_power_cap)
  ->AddVal("power_name", power_name, &cycpp_shape_power_name)
  ->AddVal("side_products", side_products, &cycpp_shape_side_products)
  ->AddVal("side_product_quantity", side_product_quantity, &cycpp_shape_side_product_quantity)
  ->AddVal("hybrid_", hybrid_, &cycpp_shape_hybrid_)
  ->AddVal("decom_transmute_all", decom_transmute_all, &cycpp_shape_decom_transmute_all)
  ->AddVal("pref_change_times", pref_change_times, &cycpp_shape_pref_change_times)
  ->AddVal("pref_change_commods", pref_change_commods, &cycpp_shape_pref_change_commods)
  ->AddVal("pref_change_values", pref_change_values, &cycpp_shape_pref_change_values)
  ->AddVal("keep_packaging", keep_packaging, &cycpp_shape_keep_packaging)
  ->AddVal("discharged", discharged, &cycpp_shape_discharged)
  ->AddVal("res_indexes", res_indexes, &cycpp_shape_res_indexes)
  ->Record();
};
#line 30 "/cycamore/src/reactor.cc"
 
void Reactor::Snapshot(cyclus::DbInit di) {
  di.NewDatum("Info")
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->AddVal("fuel_incommods", fuel_incommods, &cycpp_shape_fuel_incommods)
  ->AddVal("fuel_inrecipes", fuel_inrecipes, &cycpp_shape_fuel_inrecipes)
  ->AddVal("fuel_prefs", fuel_prefs, &cycpp_shape_fuel_prefs)
  ->AddVal("fuel_outcommods", fuel_outcommods, &cycpp_shape_fuel_outcommods)
  ->AddVal("fuel_outrecipes", fuel_outrecipes, &cycpp_shape_fuel_outrecipes)
  ->AddVal("recipe_change_times", recipe_change_times, &cycpp_shape_recipe_change_times)
  ->AddVal("recipe_change_commods", recipe_change_commods, &cycpp_shape_recipe_change_commods)
  ->AddVal("recipe_change_in", recipe_change_in, &cycpp_shape_recipe_change_in)
  ->AddVal("recipe_change_out", recipe_change_out, &cycpp_shape_recipe_change_out)
  ->AddVal("assem_size", assem_size, &cycpp_shape_assem_size)
  ->AddVal("n_assem_batch", n_assem_batch, &cycpp_shape_n_assem_batch)
  ->AddVal("n_assem_core", n_assem_core, &cycpp_shape_n_assem_core)
  ->AddVal("n_assem_fresh", n_assem_fresh, &cycpp_shape_n_assem_fresh)
  ->AddVal("n_assem_spent", n_assem_spent, &cycpp_shape_n_assem_spent)
  ->AddVal("cycle_time", cycle_time, &cycpp_shape_cycle_time)
  ->AddVal("refuel_time", refuel_time, &cycpp_shape_refuel_time)
  ->AddVal("cycle_step", cycle_step, &cycpp_shape_cycle_step)
  ->AddVal("power_cap", power_cap, &cycpp_shape_power_cap)
  ->AddVal("power_name", power_name, &cycpp_shape_power_name)
  ->AddVal("side_products", side_products, &cycpp_shape_side_products)
  ->AddVal("side_product_quantity", side_product_quantity, &cycpp_shape_side_product_quantity)
  ->AddVal("hybrid_", hybrid_, &cycpp_shape_hybrid_)
  ->AddVal("decom_transmute_all", decom_transmute_all, &cycpp_shape_decom_transmute_all)
  ->AddVal("pref_change_times", pref_change_times, &cycpp_shape_pref_change_times)
  ->AddVal("pref_change_commods", pref_change_commods, &cycpp_shape_pref_change_commods)
  ->AddVal("pref_change_values", pref_change_values, &cycpp_shape_pref_change_values)
  ->AddVal("keep_packaging", keep_packaging, &cycpp_shape_keep_packaging)
  ->AddVal("discharged", discharged, &cycpp_shape_discharged)
  ->AddVal("res_indexes", res_indexes, &cycpp_shape_res_indexes)
  ->Record();
};
#line 32 "/cycamore/src/reactor.cc"
 
cyclus::Inventories Reactor::SnapshotInv() {
  cyclus::Inventories invs;
  invs["fresh"] = fresh.PopNRes(fresh.count());
  fresh.Push(invs["fresh"]);
  invs["core"] = core.PopNRes(core.count());
  core.Push(invs["core"]);
  invs["spent"] = spent.PopNRes(spent.count());
  spent.Push(invs["spent"]);
  return invs;
};
#line 34 "/cycamore/src/reactor.cc"
 
void Reactor::InitInv(cyclus::Inventories& inv) {
  fresh.Push(inv["fresh"]);
    core.Push(inv["core"]);
    spent.Push(inv["spent"]);
  
};
#line 36 "/cycamore/src/reactor.cc"
 
void Reactor::InitFrom(Reactor* m) {    cyclus::Facility::InitFrom(m);
    int rawcycpp_shape_latitude[1] = {-1};
    cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
    int rawcycpp_shape_longitude[1] = {-1};
    cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
    int rawcycpp_shape_fuel_incommods[2] = {-1, -1};
    cycpp_shape_fuel_incommods = std::vector<int>(rawcycpp_shape_fuel_incommods, rawcycpp_shape_fuel_incommods + 2);
    int rawcycpp_shape_fuel_inrecipes[2] = {-1, -1};
    cycpp_shape_fuel_inrecipes = std::vector<int>(rawcycpp_shape_fuel_inrecipes, rawcycpp_shape_fuel_inrecipes + 2);
    int rawcycpp_shape_fuel_prefs[2] = {-1, -1};
    cycpp_shape_fuel_prefs = std::vector<int>(rawcycpp_shape_fuel_prefs, rawcycpp_shape_fuel_prefs + 2);
    int rawcycpp_shape_fuel_outcommods[2] = {-1, -1};
    cycpp_shape_fuel_outcommods = std::vector<int>(rawcycpp_shape_fuel_outcommods, rawcycpp_shape_fuel_outcommods + 2);
    int rawcycpp_shape_fuel_outrecipes[2] = {-1, -1};
    cycpp_shape_fuel_outrecipes = std::vector<int>(rawcycpp_shape_fuel_outrecipes, rawcycpp_shape_fuel_outrecipes + 2);
    int rawcycpp_shape_recipe_change_times[2] = {-1, -1};
    cycpp_shape_recipe_change_times = std::vector<int>(rawcycpp_shape_recipe_change_times, rawcycpp_shape_recipe_change_times + 2);
    int rawcycpp_shape_recipe_change_commods[2] = {-1, -1};
    cycpp_shape_recipe_change_commods = std::vector<int>(rawcycpp_shape_recipe_change_commods, rawcycpp_shape_recipe_change_commods + 2);
    int rawcycpp_shape_recipe_change_in[2] = {-1, -1};
    cycpp_shape_recipe_change_in = std::vector<int>(rawcycpp_shape_recipe_change_in, rawcycpp_shape_recipe_change_in + 2);
    int rawcycpp_shape_recipe_change_out[2] = {-1, -1};
    cycpp_shape_recipe_change_out = std::vector<int>(rawcycpp_shape_recipe_change_out, rawcycpp_shape_recipe_change_out + 2);
    int rawcycpp_shape_assem_size[1] = {-1};
    cycpp_shape_assem_size = std::vector<int>(rawcycpp_shape_assem_size, rawcycpp_shape_assem_size + 1);
    int rawcycpp_shape_n_assem_batch[1] = {-1};
    cycpp_shape_n_assem_batch = std::vector<int>(rawcycpp_shape_n_assem_batch, rawcycpp_shape_n_assem_batch + 1);
    int rawcycpp_shape_n_assem_core[1] = {-1};
    cycpp_shape_n_assem_core = std::vector<int>(rawcycpp_shape_n_assem_core, rawcycpp_shape_n_assem_core + 1);
    int rawcycpp_shape_n_assem_fresh[1] = {-1};
    cycpp_shape_n_assem_fresh = std::vector<int>(rawcycpp_shape_n_assem_fresh, rawcycpp_shape_n_assem_fresh + 1);
    int rawcycpp_shape_n_assem_spent[1] = {-1};
    cycpp_shape_n_assem_spent = std::vector<int>(rawcycpp_shape_n_assem_spent, rawcycpp_shape_n_assem_spent + 1);
    int rawcycpp_shape_cycle_time[1] = {-1};
    cycpp_shape_cycle_time = std::vector<int>(rawcycpp_shape_cycle_time, rawcycpp_shape_cycle_time + 1);
    int rawcycpp_shape_refuel_time[1] = {-1};
    cycpp_shape_refuel_time = std::vector<int>(rawcycpp_shape_refuel_time, rawcycpp_shape_refuel_time + 1);
    int rawcycpp_shape_cycle_step[1] = {-1};
    cycpp_shape_cycle_step = std::vector<int>(rawcycpp_shape_cycle_step, rawcycpp_shape_cycle_step + 1);
    int rawcycpp_shape_power_cap[1] = {-1};
    cycpp_shape_power_cap = std::vector<int>(rawcycpp_shape_power_cap, rawcycpp_shape_power_cap + 1);
    int rawcycpp_shape_power_name[1] = {-1};
    cycpp_shape_power_name = std::vector<int>(rawcycpp_shape_power_name, rawcycpp_shape_power_name + 1);
    int rawcycpp_shape_side_products[2] = {-1, -1};
    cycpp_shape_side_products = std::vector<int>(rawcycpp_shape_side_products, rawcycpp_shape_side_products + 2);
    int rawcycpp_shape_side_product_quantity[2] = {-1, -1};
    cycpp_shape_side_product_quantity = std::vector<int>(rawcycpp_shape_side_product_quantity, rawcycpp_shape_side_product_quantity + 2);
    int rawcycpp_shape_hybrid_[1] = {-1};
    cycpp_shape_hybrid_ = std::vector<int>(rawcycpp_shape_hybrid_, rawcycpp_shape_hybrid_ + 1);
    int rawcycpp_shape_decom_transmute_all[1] = {-1};
    cycpp_shape_decom_transmute_all = std::vector<int>(rawcycpp_shape_decom_transmute_all, rawcycpp_shape_decom_transmute_all + 1);
    int rawcycpp_shape_pref_change_times[2] = {-1, -1};
    cycpp_shape_pref_change_times = std::vector<int>(rawcycpp_shape_pref_change_times, rawcycpp_shape_pref_change_times + 2);
    int rawcycpp_shape_pref_change_commods[2] = {-1, -1};
    cycpp_shape_pref_change_commods = std::vector<int>(rawcycpp_shape_pref_change_commods, rawcycpp_shape_pref_change_commods + 2);
    int rawcycpp_shape_pref_change_values[2] = {-1, -1};
    cycpp_shape_pref_change_values = std::vector<int>(rawcycpp_shape_pref_change_values, rawcycpp_shape_pref_change_values + 2);
    int rawcycpp_shape_keep_packaging[1] = {-1};
    cycpp_shape_keep_packaging = std::vector<int>(rawcycpp_shape_keep_packaging, rawcycpp_shape_keep_packaging + 1);
    int rawcycpp_shape_fresh[2] = {-1, -1};
    cycpp_shape_fresh = std::vector<int>(rawcycpp_shape_fresh, rawcycpp_shape_fresh + 2);
    int rawcycpp_shape_core[2] = {-1, -1};
    cycpp_shape_core = std::vector<int>(rawcycpp_shape_core, rawcycpp_shape_core + 2);
    int rawcycpp_shape_spent[2] = {-1, -1};
    cycpp_shape_spent = std::vector<int>(rawcycpp_shape_spent, rawcycpp_shape_spent + 2);
    int rawcycpp_shape_discharged[1] = {-1};
    cycpp_shape_discharged = std::vector<int>(rawcycpp_shape_discharged, rawcycpp_shape_discharged + 1);
    int rawcycpp_shape_res_indexes[3] = {-1, -1, -1};
    cycpp_shape_res_indexes = std::vector<int>(rawcycpp_shape_res_indexes, rawcycpp_shape_res_indexes + 3);
    latitude = m->latitude;
    longitude = m->longitude;
    fuel_incommods = m->fuel_incommods;
    fuel_inrecipes = m->fuel_inrecipes;
    fuel_prefs = m->fuel_prefs;
    fuel_outcommods = m->fuel_outcommods;
    fuel_outrecipes = m->fuel_outrecipes;
    recipe_change_times = m->recipe_change_times;
    recipe_change_commods = m->recipe_change_commods;
    recipe_change_in = m->recipe_change_in;
    recipe_change_out = m->recipe_change_out;
    assem_size = m->assem_size;
    n_assem_batch = m->n_assem_batch;
    n_assem_core = m->n_assem_core;
    n_assem_fresh = m->n_assem_fresh;
    n_assem_spent = m->n_assem_spent;
    cycle_time = m->cycle_time;
    refuel_time = m->refuel_time;
    cycle_step = m->cycle_step;
    power_cap = m->power_cap;
    power_name = m->power_name;
    side_products = m->side_products;
    side_product_quantity = m->side_product_quantity;
    hybrid_ = m->hybrid_;
    decom_transmute_all = m->decom_transmute_all;
    pref_change_times = m->pref_change_times;
    pref_change_commods = m->pref_change_commods;
    pref_change_values = m->pref_change_values;
    keep_packaging = m->keep_packaging;
    discharged = m->discharged;
    res_indexes = m->res_indexes;
    fresh.capacity(m->fresh.capacity());
    core.capacity(m->core.capacity());
    spent.capacity(m->spent.capacity());
#line 43 "/cycamore/src/reactor.cc"
  cyclus::toolkit::CommodityProducer::Copy(m);
}
 
void Reactor::InitFrom(cyclus::QueryableBackend* b) {    cyclus::Facility::InitFrom(b);
    int rawcycpp_shape_latitude[1] = {-1};
    cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
    int rawcycpp_shape_longitude[1] = {-1};
    cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
    int rawcycpp_shape_fuel_incommods[2] = {-1, -1};
    cycpp_shape_fuel_incommods = std::vector<int>(rawcycpp_shape_fuel_incommods, rawcycpp_shape_fuel_incommods + 2);
    int rawcycpp_shape_fuel_inrecipes[2] = {-1, -1};
    cycpp_shape_fuel_inrecipes = std::vector<int>(rawcycpp_shape_fuel_inrecipes, rawcycpp_shape_fuel_inrecipes + 2);
    int rawcycpp_shape_fuel_prefs[2] = {-1, -1};
    cycpp_shape_fuel_prefs = std::vector<int>(rawcycpp_shape_fuel_prefs, rawcycpp_shape_fuel_prefs + 2);
    int rawcycpp_shape_fuel_outcommods[2] = {-1, -1};
    cycpp_shape_fuel_outcommods = std::vector<int>(rawcycpp_shape_fuel_outcommods, rawcycpp_shape_fuel_outcommods + 2);
    int rawcycpp_shape_fuel_outrecipes[2] = {-1, -1};
    cycpp_shape_fuel_outrecipes = std::vector<int>(rawcycpp_shape_fuel_outrecipes, rawcycpp_shape_fuel_outrecipes + 2);
    int rawcycpp_shape_recipe_change_times[2] = {-1, -1};
    cycpp_shape_recipe_change_times = std::vector<int>(rawcycpp_shape_recipe_change_times, rawcycpp_shape_recipe_change_times + 2);
    int rawcycpp_shape_recipe_change_commods[2] = {-1, -1};
    cycpp_shape_recipe_change_commods = std::vector<int>(rawcycpp_shape_recipe_change_commods, rawcycpp_shape_recipe_change_commods + 2);
    int rawcycpp_shape_recipe_change_in[2] = {-1, -1};
    cycpp_shape_recipe_change_in = std::vector<int>(rawcycpp_shape_recipe_change_in, rawcycpp_shape_recipe_change_in + 2);
    int rawcycpp_shape_recipe_change_out[2] = {-1, -1};
    cycpp_shape_recipe_change_out = std::vector<int>(rawcycpp_shape_recipe_change_out, rawcycpp_shape_recipe_change_out + 2);
    int rawcycpp_shape_assem_size[1] = {-1};
    cycpp_shape_assem_size = std::vector<int>(rawcycpp_shape_assem_size, rawcycpp_shape_assem_size + 1);
    int rawcycpp_shape_n_assem_batch[1] = {-1};
    cycpp_shape_n_assem_batch = std::vector<int>(rawcycpp_shape_n_assem_batch, rawcycpp_shape_n_assem_batch + 1);
    int rawcycpp_shape_n_assem_core[1] = {-1};
    cycpp_shape_n_assem_core = std::vector<int>(rawcycpp_shape_n_assem_core, rawcycpp_shape_n_assem_core + 1);
    int rawcycpp_shape_n_assem_fresh[1] = {-1};
    cycpp_shape_n_assem_fresh = std::vector<int>(rawcycpp_shape_n_assem_fresh, rawcycpp_shape_n_assem_fresh + 1);
    int rawcycpp_shape_n_assem_spent[1] = {-1};
    cycpp_shape_n_assem_spent = std::vector<int>(rawcycpp_shape_n_assem_spent, rawcycpp_shape_n_assem_spent + 1);
    int rawcycpp_shape_cycle_time[1] = {-1};
    cycpp_shape_cycle_time = std::vector<int>(rawcycpp_shape_cycle_time, rawcycpp_shape_cycle_time + 1);
    int rawcycpp_shape_refuel_time[1] = {-1};
    cycpp_shape_refuel_time = std::vector<int>(rawcycpp_shape_refuel_time, rawcycpp_shape_refuel_time + 1);
    int rawcycpp_shape_cycle_step[1] = {-1};
    cycpp_shape_cycle_step = std::vector<int>(rawcycpp_shape_cycle_step, rawcycpp_shape_cycle_step + 1);
    int rawcycpp_shape_power_cap[1] = {-1};
    cycpp_shape_power_cap = std::vector<int>(rawcycpp_shape_power_cap, rawcycpp_shape_power_cap + 1);
    int rawcycpp_shape_power_name[1] = {-1};
    cycpp_shape_power_name = std::vector<int>(rawcycpp_shape_power_name, rawcycpp_shape_power_name + 1);
    int rawcycpp_shape_side_products[2] = {-1, -1};
    cycpp_shape_side_products = std::vector<int>(rawcycpp_shape_side_products, rawcycpp_shape_side_products + 2);
    int rawcycpp_shape_side_product_quantity[2] = {-1, -1};
    cycpp_shape_side_product_quantity = std::vector<int>(rawcycpp_shape_side_product_quantity, rawcycpp_shape_side_product_quantity + 2);
    int rawcycpp_shape_hybrid_[1] = {-1};
    cycpp_shape_hybrid_ = std::vector<int>(rawcycpp_shape_hybrid_, rawcycpp_shape_hybrid_ + 1);
    int rawcycpp_shape_decom_transmute_all[1] = {-1};
    cycpp_shape_decom_transmute_all = std::vector<int>(rawcycpp_shape_decom_transmute_all, rawcycpp_shape_decom_transmute_all + 1);
    int rawcycpp_shape_pref_change_times[2] = {-1, -1};
    cycpp_shape_pref_change_times = std::vector<int>(rawcycpp_shape_pref_change_times, rawcycpp_shape_pref_change_times + 2);
    int rawcycpp_shape_pref_change_commods[2] = {-1, -1};
    cycpp_shape_pref_change_commods = std::vector<int>(rawcycpp_shape_pref_change_commods, rawcycpp_shape_pref_change_commods + 2);
    int rawcycpp_shape_pref_change_values[2] = {-1, -1};
    cycpp_shape_pref_change_values = std::vector<int>(rawcycpp_shape_pref_change_values, rawcycpp_shape_pref_change_values + 2);
    int rawcycpp_shape_keep_packaging[1] = {-1};
    cycpp_shape_keep_packaging = std::vector<int>(rawcycpp_shape_keep_packaging, rawcycpp_shape_keep_packaging + 1);
    int rawcycpp_shape_fresh[2] = {-1, -1};
    cycpp_shape_fresh = std::vector<int>(rawcycpp_shape_fresh, rawcycpp_shape_fresh + 2);
    int rawcycpp_shape_core[2] = {-1, -1};
    cycpp_shape_core = std::vector<int>(rawcycpp_shape_core, rawcycpp_shape_core + 2);
    int rawcycpp_shape_spent[2] = {-1, -1};
    cycpp_shape_spent = std::vector<int>(rawcycpp_shape_spent, rawcycpp_shape_spent + 2);
    int rawcycpp_shape_discharged[1] = {-1};
    cycpp_shape_discharged = std::vector<int>(rawcycpp_shape_discharged, rawcycpp_shape_discharged + 1);
    int rawcycpp_shape_res_indexes[3] = {-1, -1, -1};
    cycpp_shape_res_indexes = std::vector<int>(rawcycpp_shape_res_indexes, rawcycpp_shape_res_indexes + 3);
    cyclus::QueryResult qr = b->Query("Info", NULL);
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
    fuel_incommods = qr.GetVal<std::vector< std::string > >("fuel_incommods");
    fuel_inrecipes = qr.GetVal<std::vector< std::string > >("fuel_inrecipes");
    fuel_prefs = qr.GetVal<std::vector< double > >("fuel_prefs");
    fuel_outcommods = qr.GetVal<std::vector< std::string > >("fuel_outcommods");
    fuel_outrecipes = qr.GetVal<std::vector< std::string > >("fuel_outrecipes");
    recipe_change_times = qr.GetVal<std::vector< int > >("recipe_change_times");
    recipe_change_commods = qr.GetVal<std::vector< std::string > >("recipe_change_commods");
    recipe_change_in = qr.GetVal<std::vector< std::string > >("recipe_change_in");
    recipe_change_out = qr.GetVal<std::vector< std::string > >("recipe_change_out");
    assem_size = qr.GetVal<double>("assem_size");
    n_assem_batch = qr.GetVal<int>("n_assem_batch");
    n_assem_core = qr.GetVal<int>("n_assem_core");
    n_assem_fresh = qr.GetVal<int>("n_assem_fresh");
    n_assem_spent = qr.GetVal<int>("n_assem_spent");
    cycle_time = qr.GetVal<int>("cycle_time");
    refuel_time = qr.GetVal<int>("refuel_time");
    cycle_step = qr.GetVal<int>("cycle_step");
    power_cap = qr.GetVal<double>("power_cap");
    power_name = qr.GetVal<std::string>("power_name");
    side_products = qr.GetVal<std::vector< std::string > >("side_products");
    side_product_quantity = qr.GetVal<std::vector< double > >("side_product_quantity");
    hybrid_ = qr.GetVal<bool>("hybrid_");
    decom_transmute_all = qr.GetVal<bool>("decom_transmute_all");
    pref_change_times = qr.GetVal<std::vector< int > >("pref_change_times");
    pref_change_commods = qr.GetVal<std::vector< std::string > >("pref_change_commods");
    pref_change_values = qr.GetVal<std::vector< double > >("pref_change_values");
    keep_packaging = qr.GetVal<bool>("keep_packaging");
    discharged = qr.GetVal<bool>("discharged");
    res_indexes = qr.GetVal<std::map< int, int > >("res_indexes");
    fresh.capacity(n_assem_fresh * assem_size);
    core.capacity(n_assem_core * assem_size);
    spent.capacity(n_assem_spent * assem_size);
#line 48 "/cycamore/src/reactor.cc"
 
  namespace tk = cyclus::toolkit;
  tk::CommodityProducer::Add(tk::Commodity(power_name),
                             tk::CommodInfo(power_cap, power_cap));
 
  for (int i = 0; i < side_products.size(); i++) {
    tk::CommodityProducer::Add(tk::Commodity(side_products[i]),
                               tk::CommodInfo(side_product_quantity[i],
                                              side_product_quantity[i]));
  }
}
 
void Reactor::EnterNotify() {
  cyclus::Facility::EnterNotify();
 
  // Set keep packaging parameter in all ResBufs
  fresh.keep_packaging(keep_packaging);
  core.keep_packaging(keep_packaging);
  spent.keep_packaging(keep_packaging);
 
  // If the user ommitted fuel_prefs, we set it to zeros for each fuel
  // type.  Without this segfaults could occur - yuck.
  if (fuel_prefs.size() == 0) {
    for (int i = 0; i < fuel_outcommods.size(); i++) {
      fuel_prefs.push_back(cyclus::kDefaultPref);
    }
  }
 
  // Test if any side products have been defined.
  if (side_products.size() == 0){
    hybrid_ = false;
  }
 
  // input consistency checking:
  int n = recipe_change_times.size();
  std::stringstream ss;
  if (recipe_change_commods.size() != n) {
    ss << "prototype '" << prototype() << "' has "
       << recipe_change_commods.size()
       << " recipe_change_commods vals, expected " << n << "\n";
  }
  if (recipe_change_in.size() != n) {
    ss << "prototype '" << prototype() << "' has " << recipe_change_in.size()
       << " recipe_change_in vals, expected " << n << "\n";
  }
  if (recipe_change_out.size() != n) {
    ss << "prototype '" << prototype() << "' has " << recipe_change_out.size()
       << " recipe_change_out vals, expected " << n << "\n";
  }
 
  n = pref_change_times.size();
  if (pref_change_commods.size() != n) {
    ss << "prototype '" << prototype() << "' has " << pref_change_commods.size()
       << " pref_change_commods vals, expected " << n << "\n";
  }
  if (pref_change_values.size() != n) {
    ss << "prototype '" << prototype() << "' has " << pref_change_values.size()
       << " pref_change_values vals, expected " << n << "\n";
  }
 
  if (ss.str().size() > 0) {
    throw ValueError(ss.str());
  }
  
  InitializePosition();
}
 
bool Reactor::CheckDecommissionCondition() {
  return core.count() == 0 && spent.count() == 0;
}
 
void Reactor::Tick() {
  // The following code must go in the Tick so they fire on the time step
  // following the cycle_step update - allowing for the all reactor events to
  // occur and be recorded on the "beginning" of a time step.  Another reason
  // they
  // can't go at the beginnin of the Tock is so that resource exchange has a
  // chance to occur after the discharge on this same time step.
 
  if (retired()) {
    Record("RETIRED", "");
 
    if (context()->time() == exit_time() + 1) { // only need to transmute once
      if (decom_transmute_all == true) {
        Transmute(ceil(static_cast<double>(n_assem_core)));
      }
      else {
        Transmute(ceil(static_cast<double>(n_assem_core) / 2.0));
      }
    }
    while (core.count() > 0) {
      if (!Discharge()) {
        break;
      }
    }
    // in case a cycle lands exactly on our last time step, we will need to
    // burn a batch from fresh inventory on this time step.  When retired,
    // this batch also needs to be discharged to spent fuel inventory.
    while (fresh.count() > 0 && spent.space() >= assem_size) {
      spent.Push(fresh.Pop());
    }
    if(CheckDecommissionCondition()) {
      context()->SchedDecom(this);    
    }
    return;
  }
 
  if (cycle_step == cycle_time) {
    Transmute();
    Record("CYCLE_END", "");
  }
 
  if (cycle_step >= cycle_time && !discharged) {
    discharged = Discharge();
  }
  if (cycle_step >= cycle_time) {
    Load();
  }
 
  int t = context()->time();
 
  // update preferences
  for (int i = 0; i < pref_change_times.size(); i++) {
    int change_t = pref_change_times[i];
    if (t != change_t) {
      continue;
    }
 
    std::string incommod = pref_change_commods[i];
    for (int j = 0; j < fuel_incommods.size(); j++) {
      if (fuel_incommods[j] == incommod) {
        fuel_prefs[j] = pref_change_values[i];
        break;
      }
    }
  }
 
  // update recipes
  for (int i = 0; i < recipe_change_times.size(); i++) {
    int change_t = recipe_change_times[i];
    if (t != change_t) {
      continue;
    }
 
    std::string incommod = recipe_change_commods[i];
    for (int j = 0; j < fuel_incommods.size(); j++) {
      if (fuel_incommods[j] == incommod) {
        fuel_inrecipes[j] = recipe_change_in[i];
        fuel_outrecipes[j] = recipe_change_out[i];
        break;
      }
    }
  }
}
 
std::set<cyclus::RequestPortfolio<Material>::Ptr> Reactor::GetMatlRequests() {
  using cyclus::RequestPortfolio;
 
  std::set<RequestPortfolio<Material>::Ptr> ports;
  Material::Ptr m;
 
  // second min expression reduces assembles to amount needed until
  // retirement if it is near.
  int n_assem_order = n_assem_core - core.count() + n_assem_fresh - fresh.count();
 
  if (exit_time() != -1) {
    // the +1 accounts for the fact that the reactor is alive and gets to
    // operate during its exit_time time step.
    int t_left = exit_time() - context()->time() + 1;
    int t_left_cycle = cycle_time + refuel_time - cycle_step;
    double n_cycles_left = static_cast<double>(t_left - t_left_cycle) /
                         static_cast<double>(cycle_time + refuel_time);
    n_cycles_left = ceil(n_cycles_left);
    int n_need = std::max(0.0, n_cycles_left * n_assem_batch - n_assem_fresh + n_assem_core - core.count());
    n_assem_order = std::min(n_assem_order, n_need);
  }
 
  if (n_assem_order == 0) {
    return ports;
  } else if (retired()) {
    return ports;
  }
 
  for (int i = 0; i < n_assem_order; i++) {
    RequestPortfolio<Material>::Ptr port(new RequestPortfolio<Material>());
    std::vector<Request<Material>*> mreqs;
    for (int j = 0; j < fuel_incommods.size(); j++) {
      std::string commod = fuel_incommods[j];
      double pref = fuel_prefs[j];
      cyclus::Composition::Ptr recipe = context()->GetRecipe(fuel_inrecipes[j]);
      m = Material::CreateUntracked(assem_size, recipe);
 
      Request<Material>* r = port->AddRequest(m, this, commod, pref, true);
      mreqs.push_back(r);
    }
 
    std::vector<double>::iterator result;
    result = std::max_element(fuel_prefs.begin(), fuel_prefs.end());
    int max_index = std::distance(fuel_prefs.begin(), result);
 
    cyclus::toolkit::RecordTimeSeries<double>("demand"+fuel_incommods[max_index], this,
                                          assem_size) ;
 
    port->AddMutualReqs(mreqs);
    ports.insert(port);
  }
 
  return ports;
}
 
void Reactor::GetMatlTrades(
    const std::vector<cyclus::Trade<Material> >& trades,
    std::vector<std::pair<cyclus::Trade<Material>, Material::Ptr> >&
        responses) {
  using cyclus::Trade;
 
  std::map<std::string, MatVec> mats = PopSpent();
  for (int i = 0; i < trades.size(); i++) {
    std::string commod = trades[i].request->commodity();
    Material::Ptr m = mats[commod].back();
    mats[commod].pop_back();
    responses.push_back(std::make_pair(trades[i], m));
    res_indexes.erase(m->obj_id());
  }
  PushSpent(mats);  // return leftovers back to spent buffer
}
 
void Reactor::AcceptMatlTrades(const std::vector<
    std::pair<cyclus::Trade<Material>, Material::Ptr> >& responses) {
  std::vector<std::pair<cyclus::Trade<Material>,
                        Material::Ptr> >::const_iterator trade;
 
  std::stringstream ss;
  int nload = std::min((int)responses.size(), n_assem_core - core.count());
  if (nload > 0) {
    ss << nload << " assemblies";
    Record("LOAD", ss.str());
  }
 
  for (trade = responses.begin(); trade != responses.end(); ++trade) {
    std::string commod = trade->first.request->commodity();
    Material::Ptr m = trade->second;
    index_res(m, commod);
 
    if (core.count() < n_assem_core) {
      core.Push(m);
    } else {
      fresh.Push(m);
    }
  }
}
 
std::set<cyclus::BidPortfolio<Material>::Ptr> Reactor::GetMatlBids(
    cyclus::CommodMap<Material>::type& commod_requests) {
  using cyclus::BidPortfolio;
  std::set<BidPortfolio<Material>::Ptr> ports;
 
  bool gotmats = false;
  std::map<std::string, MatVec> all_mats;
 
  if (uniq_outcommods_.empty()) {
    for (int i = 0; i < fuel_outcommods.size(); i++) {
      uniq_outcommods_.insert(fuel_outcommods[i]);
    }
  }
 
  std::set<std::string>::iterator it;
  for (it = uniq_outcommods_.begin(); it != uniq_outcommods_.end(); ++it) {
    std::string commod = *it;
    std::vector<Request<Material>*>& reqs = commod_requests[commod];
    if (reqs.size() == 0) {
      continue;
    } else if (!gotmats) {
      all_mats = PeekSpent();
    }
 
    MatVec mats = all_mats[commod];
    if (mats.size() == 0) {
      continue;
    }
 
    BidPortfolio<Material>::Ptr port(new BidPortfolio<Material>());
 
    for (int j = 0; j < reqs.size(); j++) {
      Request<Material>* req = reqs[j];
      double tot_bid = 0;
      for (int k = 0; k < mats.size(); k++) {
        Material::Ptr m = mats[k];
        tot_bid += m->quantity();
        port->AddBid(req, m, this, true);
        if (tot_bid >= req->target()->quantity()) {
          break;
        }
      }
    }
 
    double tot_qty = 0;
    for (int j = 0; j < mats.size(); j++) {
      tot_qty += mats[j]->quantity();
    }
 
    cyclus::CapacityConstraint<Material> cc(tot_qty);
    port->AddConstraint(cc);
    ports.insert(port);
  }
 
  return ports;
}
 
void Reactor::Tock() {
  if (retired()) {
    return;
  }
  
  // Check that irradiation and refueling periods are over, that 
  // the core is full and that fuel was successfully discharged in this refueling time.
  // If this is the case, then a new cycle will be initiated.
  if (cycle_step >= cycle_time + refuel_time && core.count() == n_assem_core && discharged == true) {
    discharged = false;
    cycle_step = 0;
  }
 
  if (cycle_step == 0 && core.count() == n_assem_core) {
    Record("CYCLE_START", "");
  }
 
  if (cycle_step >= 0 && cycle_step < cycle_time &&
      core.count() == n_assem_core) {
    cyclus::toolkit::RecordTimeSeries<cyclus::toolkit::POWER>(this, power_cap);
    cyclus::toolkit::RecordTimeSeries<double>("supplyPOWER", this, power_cap);
    RecordSideProduct(true);
  } else {
    cyclus::toolkit::RecordTimeSeries<cyclus::toolkit::POWER>(this, 0);
    cyclus::toolkit::RecordTimeSeries<double>("supplyPOWER", this, 0);
    RecordSideProduct(false);
  }
 
  // "if" prevents starting cycle after initial deployment until core is full
  // even though cycle_step is its initial zero.
  if (cycle_step > 0 || core.count() == n_assem_core) {
    cycle_step++;
  }
}
 
void Reactor::Transmute() { Transmute(n_assem_batch); }
 
void Reactor::Transmute(int n_assem) {
  MatVec old = core.PopN(std::min(n_assem, core.count()));
  core.Push(old);
  if (core.count() > old.size()) {
    // rotate untransmuted mats back to back of buffer
    core.Push(core.PopN(core.count() - old.size()));
  }
 
  std::stringstream ss;
  ss << old.size() << " assemblies";
  Record("TRANSMUTE", ss.str());
 
  for (int i = 0; i < old.size(); i++) {
    old[i]->Transmute(context()->GetRecipe(fuel_outrecipe(old[i])));
  }
}
 
std::map<std::string, MatVec> Reactor::PeekSpent() {
  std::map<std::string, MatVec> mapped;
  MatVec mats = spent.PopN(spent.count());
  spent.Push(mats);
  for (int i = 0; i < mats.size(); i++) {
    std::string commod = fuel_outcommod(mats[i]);
    mapped[commod].push_back(mats[i]);
  }
  return mapped;
}
 
bool Reactor::Discharge() {
  int npop = std::min(n_assem_batch, core.count());
  if (n_assem_spent - spent.count() < npop) {
    Record("DISCHARGE", "failed");
    return false;  // not enough room in spent buffer
  }
 
  std::stringstream ss;
  ss << npop << " assemblies";
  Record("DISCHARGE", ss.str());
  spent.Push(core.PopN(npop));
 
  std::map<std::string, MatVec> spent_mats;
  for (int i = 0; i < fuel_outcommods.size(); i++) {
    spent_mats = PeekSpent();
    MatVec mats = spent_mats[fuel_outcommods[i]];
    double tot_spent = 0;
    for (int j = 0; j<mats.size(); j++){
      Material::Ptr m = mats[j];
      tot_spent += m->quantity();
    }
    cyclus::toolkit::RecordTimeSeries<double>("supply"+fuel_outcommods[i], this, tot_spent);
  }
 
  return true;
}
 
void Reactor::Load() {
  int n = std::min(n_assem_core - core.count(), fresh.count());
  if (n == 0) {
    return;
  }
 
  std::stringstream ss;
  ss << n << " assemblies";
  Record("LOAD", ss.str());
  core.Push(fresh.PopN(n));
}
 
std::string Reactor::fuel_incommod(Material::Ptr m) {
  int i = res_indexes[m->obj_id()];
  if (i >= fuel_incommods.size()) {
    throw KeyError("cycamore::Reactor - no incommod for material object");
  }
  return fuel_incommods[i];
}
 
std::string Reactor::fuel_outcommod(Material::Ptr m) {
  int i = res_indexes[m->obj_id()];
  if (i >= fuel_outcommods.size()) {
    throw KeyError("cycamore::Reactor - no outcommod for material object");
  }
  return fuel_outcommods[i];
}
 
std::string Reactor::fuel_inrecipe(Material::Ptr m) {
  int i = res_indexes[m->obj_id()];
  if (i >= fuel_inrecipes.size()) {
    throw KeyError("cycamore::Reactor - no inrecipe for material object");
  }
  return fuel_inrecipes[i];
}
 
std::string Reactor::fuel_outrecipe(Material::Ptr m) {
  int i = res_indexes[m->obj_id()];
  if (i >= fuel_outrecipes.size()) {
    throw KeyError("cycamore::Reactor - no outrecipe for material object");
  }
  return fuel_outrecipes[i];
}
 
double Reactor::fuel_pref(Material::Ptr m) {
  int i = res_indexes[m->obj_id()];
  if (i >= fuel_prefs.size()) {
    return 0;
  }
  return fuel_prefs[i];
}
 
void Reactor::index_res(cyclus::Resource::Ptr m, std::string incommod) {
  for (int i = 0; i < fuel_incommods.size(); i++) {
    if (fuel_incommods[i] == incommod) {
      res_indexes[m->obj_id()] = i;
      return;
    }
  }
  throw ValueError(
      "cycamore::Reactor - received unsupported incommod material");
}
 
std::map<std::string, MatVec> Reactor::PopSpent() {
  MatVec mats = spent.PopN(spent.count());
  std::map<std::string, MatVec> mapped;
  for (int i = 0; i < mats.size(); i++) {
    std::string commod = fuel_outcommod(mats[i]);
    mapped[commod].push_back(mats[i]);
  }
 
  // needed so we trade away oldest assemblies first
  std::map<std::string, MatVec>::iterator it;
  for (it = mapped.begin(); it != mapped.end(); ++it) {
    std::reverse(it->second.begin(), it->second.end());
  }
 
  return mapped;
}
 
void Reactor::PushSpent(std::map<std::string, MatVec> leftover) {
  std::map<std::string, MatVec>::iterator it;
  for (it = leftover.begin(); it != leftover.end(); ++it) {
    // undo reverse in PopSpent to make sure oldest assemblies come out first
    std::reverse(it->second.begin(), it->second.end());
    spent.Push(it->second);
  }
}
 
void Reactor::RecordSideProduct(bool produce){
  if (hybrid_){
    double value;
    for (int i = 0; i < side_products.size(); i++) {
      if (produce){
          value = side_product_quantity[i];
      }
      else {
          value = 0;
      }
 
      context()
          ->NewDatum("ReactorSideProducts")
          ->AddVal("AgentId", id())
          ->AddVal("Time", context()->time())
          ->AddVal("Product", side_products[i])
          ->AddVal("Value", value)
          ->Record();
    }
  }
}
 
void Reactor::Record(std::string name, std::string val) {
  context()
      ->NewDatum("ReactorEvents")
      ->AddVal("AgentId", id())
      ->AddVal("Time", context()->time())
      ->AddVal("Event", name)
      ->AddVal("Value", val)
      ->Record();
}
 
extern "C" cyclus::Agent* ConstructReactor(cyclus::Context* ctx) {
  return new Reactor(ctx);
}
 
}  // namespace cycamore