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),
      latitude(0.0),
      longitude(0.0),
      keep_packaging(true),
      coordinates(latitude, longitude) {}
cyclus::Agent* Reactor::Clone() {
  cycamore::Reactor* m = new cycamore::Reactor(context());
  m->InitFrom(this);
  return m;
};
#line 28 "/cycamore/src/reactor.cc"
 
std::string Reactor::schema() {
  return ""
    "<interleave>\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"
    "        <data type=\"double\"/>\n"
    "    </element>\n"
    "    <element name=\"n_assem_batch\">\n"
    "        <data type=\"int\"/>\n"
    "    </element>\n"
    "    <optional>\n"
    "        <element name=\"n_assem_core\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"n_assem_fresh\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"n_assem_spent\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"cycle_time\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"refuel_time\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"cycle_step\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"power_cap\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"power_name\">\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"
    "            <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"
    "            <data type=\"boolean\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"latitude\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"longitude\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "</interleave>\n";
};
#line 29 "/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\":[\"cyclus::Agent\",\"cyclus::Facility\",\"cyclu"
    "s::Ider\",\"cyclus::StateWrangler\",\"cyclus::TimeList"
    "ener\",\"cyclus::Trader\",\"cyclus::toolkit::AgentMana"
    "ged\",\"cyclus::toolkit::CommodityProducer\",\"cyclus:"
    ":toolkit::Position\"],\"vars\":{\"fuel_incommods\":{\"ui"
    "type\":[\"oneormore\",\"incommodity\"],\"uilabel\":[\"Fres"
    "h Fuel Commodity List\",\"\"],\"doc\":\"Ordered list of "
    "input commodities on which to requesting fuel.\",\"t"
    "ype\":[\"std::vector\",\"std::string\"],\"index\":0,\"shap"
    "e\":[-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\":1,\"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\":2,\"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\":3,\"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\":4,\"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\":"
    "5,\"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\":6,\"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\":7,\"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\":8,\"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\":9,\"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\":10,\"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\":11,\"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\":12,\"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\":13,\"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\":"
    "14,\"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"
    "\":15,\"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"
    "6,\"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\":17,\"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\":18,\"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\""
    ":19,\"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"
    "\":20,\"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\":21,\"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\":22,\"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\":23,\"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\":24,\"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\":25,\"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\":26,\"shape\":[-"
    "1],\"alias\":\"keep_packaging\"},\"fresh\":{\"capacity\":\""
    "n_assem_fresh * assem_size\",\"type\":[\"cyclus::toolk"
    "it::ResBuf\",\"cyclus::Material\"],\"index\":27,\"shape\""
    ":[-1,-1]},\"core\":{\"capacity\":\"n_assem_core * assem"
    "_size\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::"
    "Material\"],\"index\":28,\"shape\":[-1,-"
    "1]},\"spent\":{\"capacity\":\"n_assem_spent * assem_siz"
    "e\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::Mate"
    "rial\"],\"index\":29,\"shape\":[-1,-"
    "1]},\"discharged\":{\"default\":0,\"doc\":\"This should "
    "NEVER be set manually\",\"internal\":true,\"type\":\"boo"
    "l\",\"index\":30,\"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\":31,"
    "\"shape\":[-1,-1,-"
    "1],\"alias\":[[\"res_indexes\",\"item\"],\"key\",\"val\"],\"t"
    "ooltip\":[[\"res_indexes\",\"\"],\"\",\"\"],\"uilabel\":[[\"re"
    "s_indexes\",\"\"],\"\",\"\"]},\"latitude\":{\"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\":32,\"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\":33,\"shape\":[-"
    "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"}},\"ni"
    "che\":\"reactor\",\"doc\":\"Reactor is a simple, general"
    " reactor based on static compositional "
    "transformations to model fuel burnup.  The user "
    "specifies a set of input fuels and corresponding "
    "burnt compositions that fuel is transformed to "
    "when it is discharged from the core.  No "
    "incremental transmutation takes place. Rather, at "
    "the end of an operational cycle, the batch being "
    "discharged from the core is instantaneously "
    "transmuted from its original fresh fuel "
    "composition into its spent fuel form.\\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 31 "/cycamore/src/reactor.cc"
 
void Reactor::InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
  cyclus::Facility::InfileToDb(tree, di);
  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);
  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);
  cyclus::InfileTree* sub = tree->SubTree("config/*");
  int i;
  int n;
  {
    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;
  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;
  }
  di.NewDatum("Info")
  ->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)
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->Record();
};
#line 33 "/cycamore/src/reactor.cc"
 
void Reactor::Snapshot(cyclus::DbInit di) {
  di.NewDatum("Info")
  ->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)
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->Record();
};
#line 35 "/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 37 "/cycamore/src/reactor.cc"
 
void Reactor::InitInv(cyclus::Inventories& inv) {
  fresh.Push(inv["fresh"]);
    core.Push(inv["core"]);
    spent.Push(inv["spent"]);
  
};
#line 39 "/cycamore/src/reactor.cc"
 
void Reactor::InitFrom(Reactor* m) {    cyclus::Facility::InitFrom(m);
    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);
    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);
    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;
    latitude = m->latitude;
    longitude = m->longitude;
    fresh.capacity(m->fresh.capacity());
    core.capacity(m->core.capacity());
    spent.capacity(m->spent.capacity());
#line 46 "/cycamore/src/reactor.cc"
  cyclus::toolkit::CommodityProducer::Copy(m);
}
 
void Reactor::InitFrom(cyclus::QueryableBackend* b) {    cyclus::Facility::InitFrom(b);
    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);
    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);
    cyclus::QueryResult qr = b->Query("Info", NULL);
    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");
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
    fresh.capacity(n_assem_fresh * assem_size);
    core.capacity(n_assem_core * assem_size);
    spent.capacity(n_assem_spent * assem_size);
#line 51 "/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());
  }
  RecordPosition();
}
 
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();
}
 
void Reactor::RecordPosition() {
  std::string specification = this->spec();
  context()
      ->NewDatum("AgentPosition")
      ->AddVal("Spec", specification)
      ->AddVal("Prototype", this->prototype())
      ->AddVal("AgentId", id())
      ->AddVal("Latitude", latitude)
      ->AddVal("Longitude", longitude)
      ->Record();
}
 
extern "C" cyclus::Agent* ConstructReactor(cyclus::Context* ctx) {
  return new Reactor(ctx);
}
 
}  // namespace cycamore