build/cycamore/storage.cc

Go to the documentation of this file.

#line 1 "/cycamore/src/storage.cc"
// storage.cc
// Implements the Storage class
#include "storage.h"
 
namespace cycamore {
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Storage::Storage(cyclus::Context* ctx)
    : cyclus::Facility(ctx),
      latitude(0.0),
      longitude(0.0),
      coordinates(latitude, longitude) {
  inventory_tracker.Init({&inventory, &stocks, &ready, &processing}, cyclus::CY_LARGE_DOUBLE);
  cyclus::Warn<cyclus::EXPERIMENTAL_WARNING>(
      "The Storage Facility is experimental.");};
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// pragmas
 
std::string Storage::schema() {
  return ""
    "<interleave>\n"
    "    <element name=\"in_commods\">\n"
    "        <oneOrMore>\n"
    "            <element name=\"val\">\n"
    "                <data type=\"string\"/>\n"
    "            </element>\n"
    "        </oneOrMore>\n"
    "    </element>\n"
    "    <optional>\n"
    "        <element name=\"in_commod_prefs\">\n"
    "            <oneOrMore>\n"
    "                <element name=\"val\">\n"
    "                    <data type=\"double\"/>\n"
    "                </element>\n"
    "            </oneOrMore>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <element name=\"out_commods\">\n"
    "        <oneOrMore>\n"
    "            <element name=\"val\">\n"
    "                <data type=\"string\"/>\n"
    "            </element>\n"
    "        </oneOrMore>\n"
    "    </element>\n"
    "    <optional>\n"
    "        <element name=\"in_recipe\">\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"residence_time\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"sell_quantity\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"throughput\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"max_inv_size\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"discrete_handling\">\n"
    "            <data type=\"boolean\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_frequency_type\">\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_val\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_min\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_max\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_mean\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_stddev\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_frequency_type\">\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_val\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_min\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_max\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_mean\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_stddev\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_type\">\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_val\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_min\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_max\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_mean\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_stddev\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"reorder_point\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"reorder_quantity\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"cumulative_cap\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"package\">\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"transport_unit\">\n"
    "            <data type=\"string\"/>\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 21 "/cycamore/src/storage.cc"
 
Json::Value Storage::annotations() {
  Json::Value root;
  Json::Reader reader;
  bool parsed_ok = reader.parse(
    "{\"name\":\"cycamore::Storage\",\"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\":{\"in_commods\":{\"toolti"
    "p\":[\"input commodity\",\"\"],\"doc\":\"commodities "
    "accepted by this facility\",\"uilabel\":[\"Input Commo"
    "dities\",\"\"],\"uitype\":[\"oneormore\",\"incommodity\"],\""
    "type\":[\"std::vector\",\"std::string\"],\"index\":0,\"sha"
    "pe\":[-1,-"
    "1],\"alias\":[\"in_commods\",\"val\"]},\"in_commod_prefs\""
    ":{\"default\":[],\"doc\":\"preferences for each of the "
    "given commodities, in the same order.Defauts to 1 "
    "if unspecified\",\"uilabel\":[\"In Commody Preferences"
    "\",\"\"],\"range\":[null,[1e-"
    "08,1e+299]],\"uitype\":[\"oneormore\",\"range\"],\"type\":"
    "[\"std::vector\",\"double\"],\"index\":1,\"shape\":[-1,-"
    "1],\"alias\":[\"in_commod_prefs\",\"val\"],\"tooltip\":[\"i"
    "n_commod_prefs\",\"\"]},\"out_commods\":{\"tooltip\":[\"ou"
    "tput commodity\",\"\"],\"doc\":\"commodity produced by "
    "this facility. Multiple commodity tracking is "
    "currently not supported, one output commodity "
    "catches all input commodities.\",\"uilabel\":[\"Output"
    " Commodities\",\"\"],\"uitype\":[\"oneormore\",\"outcommod"
    "ity\"],\"type\":[\"std::vector\",\"std::string\"],\"index\""
    ":2,\"shape\":[-1,-"
    "1],\"alias\":[\"out_commods\",\"val\"]},\"in_recipe\":{\"de"
    "fault\":\"\",\"tooltip\":\"input recipe\",\"doc\":\"recipe "
    "accepted by this facility, if unspecified a dummy "
    "recipe is used\",\"uilabel\":\"Input Recipe\",\"uitype\":"
    "\"inrecipe\",\"type\":\"std::string\",\"index\":3,\"shape\":"
    "[-"
    "1],\"alias\":\"in_recipe\"},\"residence_time\":{\"default"
    "\":0,\"tooltip\":\"residence time "
    "(timesteps)\",\"doc\":\"the minimum holding time for a"
    " received commodity (timesteps).\",\"units\":\"time "
    "steps\",\"uilabel\":\"Residence Time\",\"uitype\":\"range\""
    ",\"range\":[0,12000],\"type\":\"int\",\"index\":4,\"shape\":"
    "[-"
    "1],\"alias\":\"residence_time\"},\"sell_quantity\":{\"def"
    "ault\":0,\"tooltip\":\"sell quantity "
    "(kg)\",\"doc\":\"material will be sold in integer "
    "multiples of this quantity. If the buffer contains"
    " less than the sell quantity, no material will be "
    "offered\",\"uilabel\":\"Sell Quantity\",\"uitype\":\"range"
    "\",\"range\":[0.0,1e+299],\"units\":\"kg\",\"type\":\"double"
    "\",\"index\":5,\"shape\":[-"
    "1],\"alias\":\"sell_quantity\"},\"throughput\":{\"default"
    "\":1e+299,\"tooltip\":\"throughput per timestep "
    "(kg)\",\"doc\":\"the max amount that can be moved "
    "through the facility per timestep (kg)\",\"uilabel\":"
    "\"Throughput\",\"uitype\":\"range\",\"range\":[0.0,1e+299]"
    ",\"units\":\"kg\",\"type\":\"double\",\"index\":6,\"shape\":[-"
    "1],\"alias\":\"throughput\"},\"max_inv_size\":{\"default\""
    ":1e+299,\"tooltip\":\"maximum inventory size "
    "(kg)\",\"doc\":\"the maximum amount of material that "
    "can be in all storage buffer "
    "stages\",\"uilabel\":\"Maximum Inventory Size\",\"uitype"
    "\":\"range\",\"range\":[0.0,1e+299],\"units\":\"kg\",\"type\""
    ":\"double\",\"index\":7,\"shape\":[-"
    "1],\"alias\":\"max_inv_size\"},\"discrete_handling\":{\"d"
    "efault\":false,\"tooltip\":\"Bool to determine how "
    "Storage handles batches\",\"doc\":\"Determines if "
    "Storage will divide resource objects. Only "
    "controls material handling within this facility, "
    "has no effect on DRE material handling. If true, "
    "batches are handled as discrete quanta, neither "
    "split nor combined. Otherwise, batches may be "
    "divided during processing. Default to false "
    "(continuous))\",\"uilabel\":\"Batch Handling\",\"type\":\""
    "bool\",\"index\":8,\"shape\":[-"
    "1],\"alias\":\"discrete_handling\"},\"active_buying_fre"
    "quency_type\":{\"default\":\"Fixed\",\"tooltip\":\"Type of"
    " active buying frequency\",\"doc\":\"Options: Fixed, "
    "Uniform, Normal. Fixed requires active_buying_val."
    " Uniform requires active_buying_min and "
    "active_buying_max.  Normal requires "
    "active_buying_mean and active_buying_std, with "
    "optional active_buying_min and active_buying_max.\""
    ",\"uitype\":\"combobox\",\"categorical\":[\"Fixed\",\"Unifo"
    "rm\",\"Normal\"],\"uilabel\":\"Active Buying Frequency T"
    "ype\",\"type\":\"std::string\",\"index\":9,\"shape\":[-"
    "1],\"alias\":\"active_buying_frequency_type\"},\"active"
    "_buying_val\":{\"default\":-1,\"tooltip\":\"Fixed active"
    " buying frequency\",\"doc\":\"The length in time steps"
    " of the active buying period. Required for fixed "
    "active_buying_frequency_type. Must be greater than"
    " or equal to 1 (i.e., agent cannot always be dorma"
    "nt)\",\"uitype\":\"range\",\"range\":[1,2147483647],\"uila"
    "bel\":\"Active Buying Frequency Value\",\"type\":\"int\","
    "\"index\":10,\"shape\":[-"
    "1],\"alias\":\"active_buying_val\"},\"active_buying_min"
    "\":{\"default\":-1,\"tooltip\":\"Active buying "
    "distribution minimum\",\"doc\":\"The minimum length in"
    " time steps of the active buying period. Required "
    "for Uniform and optional for Normal "
    "active_buying_frequency_type. Must be greater than"
    " or equal to 1 \",\"uitype\":\"range\",\"range\":[1,21474"
    "83647],\"uilabel\":\"Active Buying Frequency Minimum\""
    ",\"type\":\"int\",\"index\":11,\"shape\":[-"
    "1],\"alias\":\"active_buying_min\"},\"active_buying_max"
    "\":{\"default\":-1,\"tooltip\":\"Active buying "
    "distribution maximum\",\"doc\":\"The maximum length in"
    " time steps of the active buying period. Required "
    "for Uniform active_buying_frequency_type, optional"
    " for Normal. Must be greater than or equal to "
    "active_buying_min \",\"uitype\":\"range\",\"range\":[1,21"
    "47483647],\"uilabel\":\"Active Buying Frequency Maxim"
    "um\",\"type\":\"int\",\"index\":12,\"shape\":[-"
    "1],\"alias\":\"active_buying_max\"},\"active_buying_mea"
    "n\":{\"default\":-1,\"tooltip\":\"Active buying "
    "distribution mean\",\"doc\":\"The mean length in time "
    "steps of the active buying period. Required for "
    "Normal active_buying_frequency_type. Must be "
    "greater than or equal to 1 \",\"uitype\":\"range\",\"ran"
    "ge\":[1.0,1e+299],\"uilabel\":\"Active Buying "
    "Frequency Mean\",\"type\":\"double\",\"index\":13,\"shape\""
    ":[-"
    "1],\"alias\":\"active_buying_mean\"},\"active_buying_st"
    "ddev\":{\"default\":-1,\"tooltip\":\"Active buying "
    "distribution standard deviation\",\"doc\":\"The "
    "standard deviation of the length in time steps of "
    "the active buying period. Required for Normal "
    "active_buying_frequency_type. Must be greater than"
    " or equal to 0 \",\"uitype\":\"range\",\"range\":[0.0,1e+"
    "299],\"uilabel\":\"Active Buying Frequency Standard D"
    "eviation\",\"type\":\"double\",\"index\":14,\"shape\":[-"
    "1],\"alias\":\"active_buying_stddev\"},\"dormant_buying"
    "_frequency_type\":{\"default\":\"Fixed\",\"tooltip\":\"Typ"
    "e of dormant buying frequency\",\"doc\":\"Options: "
    "Fixed, Uniform, Normal. Fixed requires "
    "dormant_buying_val. Uniform requires "
    "dormant_buying_min and dormant_buying_max. Normal "
    "requires dormant_buying_mean and "
    "dormant_buying_std, with optional "
    "dormant_buying_min and dormant_buying_max.\",\"uityp"
    "e\":\"combobox\",\"categorical\":[\"Fixed\",\"Uniform\",\"No"
    "rmal\"],\"uilabel\":\"Dormant Buying Frequency Type\",\""
    "type\":\"std::string\",\"index\":15,\"shape\":[-"
    "1],\"alias\":\"dormant_buying_frequency_type\"},\"dorma"
    "nt_buying_val\":{\"default\":-1,\"tooltip\":\"Fixed "
    "dormant buying frequency\",\"doc\":\"The length in "
    "time steps of the dormant buying period. Required "
    "for fixed dormant_buying_frequency_type. Default "
    "is -1, agent has no dormant period and stays activ"
    "e.\",\"uitype\":\"range\",\"range\":[-"
    "1,2147483647],\"uilabel\":\"Dormant Buying Frequency "
    "Value\",\"type\":\"int\",\"index\":16,\"shape\":[-"
    "1],\"alias\":\"dormant_buying_val\"},\"dormant_buying_m"
    "in\":{\"default\":-1,\"tooltip\":\"Dormant buying "
    "distribution minimum\",\"doc\":\"The minimum length in"
    " time steps of the dormant buying period. Required"
    " for Uniform and optional for Normal dormant_buyin"
    "g_frequency_type.\",\"uitype\":\"range\",\"range\":[0,214"
    "7483647],\"uilabel\":\"Dormant Buying Frequency Minim"
    "um\",\"type\":\"int\",\"index\":17,\"shape\":[-"
    "1],\"alias\":\"dormant_buying_min\"},\"dormant_buying_m"
    "ax\":{\"default\":-1,\"tooltip\":\"Dormant buying "
    "distribution maximum\",\"doc\":\"The maximum length in"
    " time steps of the dormant buying period. Required"
    " for Uniform dormant_buying_frequency_type, "
    "optional for Normal. Must be greater than or equal"
    " to dormant_buying_min \",\"uitype\":\"range\",\"range\":"
    "[0,2147483647],\"uilabel\":\"Dormant Buying Frequency"
    " Maximum\",\"type\":\"int\",\"index\":18,\"shape\":[-"
    "1],\"alias\":\"dormant_buying_max\"},\"dormant_buying_m"
    "ean\":{\"default\":-1,\"tooltip\":\"Dormant buying "
    "distribution mean\",\"doc\":\"The mean length in time "
    "steps of the dormant buying period. Required for "
    "Normal dormant_buying_frequency_type. Must be "
    "greater than or equal to 0 \",\"uitype\":\"range\",\"ran"
    "ge\":[0.0,1e+299],\"uilabel\":\"Dormant Buying "
    "Frequency Mean\",\"type\":\"double\",\"index\":19,\"shape\""
    ":[-"
    "1],\"alias\":\"dormant_buying_mean\"},\"dormant_buying_"
    "stddev\":{\"default\":-1,\"tooltip\":\"Dormant buying "
    "distribution standard deviation\",\"doc\":\"The "
    "standard deviation of the length in time steps of "
    "the dormant buying period. Required for Normal "
    "dormant_buying_frequency_type. Must be greater "
    "than or equal to 0 \",\"uitype\":\"range\",\"range\":[0.0"
    ",1e+299],\"uilabel\":\"Dormant Buying Frequency "
    "Standard Deviation\",\"type\":\"double\",\"index\":20,\"sh"
    "ape\":[-"
    "1],\"alias\":\"dormant_buying_stddev\"},\"buying_size_t"
    "ype\":{\"default\":\"Fixed\",\"tooltip\":\"Type of "
    "behavior used to determine size of buy "
    "request\",\"doc\":\"Behavior function used to "
    "determine the size of requests made. All values "
    "are a fraction of maximum capacity, determined by "
    "the throughput and capacity remaining. Options: "
    "Fixed, Uniform, Normal. Fixed is default behavior."
    " Uniform requires buying_size_min and "
    "buying_size_max. Normal requires buying_size_mean "
    "and buying_size_stddev, optional buying_size_min "
    "and buying_size_max.\",\"uitype\":\"combobox\",\"categor"
    "ical\":[\"Fixed\",\"Uniform\",\"Normal\"],\"uilabel\":\"Buyi"
    "ng Size Type\",\"type\":\"std::string\",\"index\":21,\"sha"
    "pe\":[-"
    "1],\"alias\":\"buying_size_type\"},\"buying_size_val\":{"
    "\"default\":1.0,\"tooltip\":\"Fixed buying "
    "size\",\"doc\":\"The size of the buy request as a "
    "fraction of maximum capacity. Optional for Fixed "
    "buying_size_type. Must be greater than or equal to"
    " 0.0\",\"uitype\":\"range\",\"range\":[0.0,1.0],\"uilabel\""
    ":\"Buying Size Value\",\"type\":\"double\",\"index\":22,\"s"
    "hape\":[-"
    "1],\"alias\":\"buying_size_val\"},\"buying_size_min\":{\""
    "default\":-1.0,\"tooltip\":\"Buying size distribution "
    "minimum\",\"doc\":\"The minimum size of the buy "
    "request as a fraction of maximum capacity. "
    "Required for Uniform and optional for Normal "
    "buying_size_type. Must be greater than or equal to"
    " zero.\",\"uitype\":\"range\",\"range\":[0.0,1.0],\"uilabe"
    "l\":\"Buying Size Minimum\",\"type\":\"double\",\"index\":2"
    "3,\"shape\":[-"
    "1],\"alias\":\"buying_size_min\"},\"buying_size_max\":{\""
    "default\":-1.0,\"tooltip\":\"Buying size distribution "
    "maximum\",\"doc\":\"The maximum size of the buy "
    "request as a fraction of maximum capacity. "
    "Required for Uniform buying_size_type, optional "
    "for Normal. Must be greater than or equal to "
    "buying_size_min \",\"uitype\":\"range\",\"range\":[0.0,1."
    "0],\"uilabel\":\"Buying Size Maximum\",\"type\":\"double\""
    ",\"index\":24,\"shape\":[-"
    "1],\"alias\":\"buying_size_max\"},\"buying_size_mean\":{"
    "\"default\":-1.0,\"tooltip\":\"Buying size distribution"
    " mean\",\"doc\":\"The mean size of the buy request as "
    "a fraction of maximum capacity. Required for "
    "Normal buying_size_type.\",\"uitype\":\"range\",\"range\""
    ":[0.0,1.0],\"uilabel\":\"Buying Size Mean\",\"type\":\"do"
    "uble\",\"index\":25,\"shape\":[-"
    "1],\"alias\":\"buying_size_mean\"},\"buying_size_stddev"
    "\":{\"default\":-1.0,\"tooltip\":\"Buying size "
    "distribution standard deviation\",\"doc\":\"The "
    "standard deviation of the size of the buy request "
    "as a fraction of maximum capacity. Required for "
    "Normal buying_size_type.\",\"uitype\":\"range\",\"range\""
    ":[0.0,1.0],\"uilabel\":\"Buying Size Standard Deviati"
    "on\",\"type\":\"double\",\"index\":26,\"shape\":[-"
    "1],\"alias\":\"buying_size_stddev\"},\"reorder_point\":{"
    "\"default\":-1,\"tooltip\":\"Reorder point\",\"doc\":\"The "
    "point at which the facility will request more "
    "material. Above this point, no request will be "
    "made. Must be less than max_inv_size.If paired "
    "with reorder_quantity, this agent will have an "
    "(R,Q) inventory policy. If reorder_point is used "
    "alone, this agent will have an (s,S) inventory "
    "policy,  with S (the maximum) being set at "
    "max_inv_size.\",\"uilabel\":\"Reorder Point\",\"type\":\"d"
    "ouble\",\"index\":27,\"shape\":[-"
    "1],\"alias\":\"reorder_point\"},\"reorder_quantity\":{\"d"
    "efault\":-1,\"tooltip\":\"Reorder amount (R,Q "
    "inventory policy)\",\"doc\":\"The amount of material "
    "that will be requested when the reorder point is "
    "reached. Exclusive request, so will demand exactly"
    " reorder_quantity.Reorder_point + reorder_quantity"
    " must be less than "
    "max_inv_size.\",\"uilabel\":\"Reorder Quantity\",\"type\""
    ":\"double\",\"index\":28,\"shape\":[-"
    "1],\"alias\":\"reorder_quantity\"},\"cumulative_cap\":{\""
    "default\":-1,\"tooltip\":\"Total amount of material "
    "that can be recieved per cycle.\",\"doc\":\"After "
    "receiving this much material cumulatively, the "
    "agent will go dormant. Must be paired with "
    "dormant_buying_frequency_type and any other "
    "dormant parameters. The per-time step demand is "
    "unchanged except the cycle cap is almost "
    "reached.\",\"uilabel\":\"Cumulative Cap\",\"type\":\"doubl"
    "e\",\"index\":29,\"shape\":[-"
    "1],\"alias\":\"cumulative_cap\"},\"package\":{\"default\":"
    "\"unpackaged\",\"tooltip\":\"Output "
    "package\",\"doc\":\"Outgoing material will be packaged"
    " when trading.\",\"uitype\":\"package\",\"uilabel\":\"Pack"
    "age\",\"type\":\"std::string\",\"index\":30,\"shape\":[-"
    "1],\"alias\":\"package\"},\"transport_unit\":{\"default\":"
    "\"unrestricted\",\"tooltip\":\"Output transport "
    "unit\",\"doc\":\"Outgoing material, after packaging, "
    "will be further restricted by transport unit when "
    "trading.\",\"uitype\":\"transportunit\",\"uilabel\":\"Tran"
    "sport Unit\",\"type\":\"std::string\",\"index\":31,\"shape"
    "\":[-"
    "1],\"alias\":\"transport_unit\"},\"inventory\":{\"tooltip"
    "\":\"Incoming material buffer\",\"type\":[\"cyclus::tool"
    "kit::ResBuf\",\"cyclus::Material\"],\"index\":32,\"shape"
    "\":[-1,-1]},\"stocks\":{\"tooltip\":\"Output material bu"
    "ffer\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::M"
    "aterial\"],\"index\":33,\"shape\":[-1,-"
    "1]},\"ready\":{\"tooltip\":\"Buffer for material held "
    "for required residence_time\",\"type\":[\"cyclus::tool"
    "kit::ResBuf\",\"cyclus::Material\"],\"index\":34,\"shape"
    "\":[-1,-1]},\"processing\":{\"tooltip\":\"Buffer for "
    "material still waiting for required residence_time"
    "\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::Mater"
    "ial\"],\"index\":35,\"shape\":[-1,-"
    "1]},\"inventory_tracker\":{\"tooltip\":\"Total "
    "Inventory Tracker to restrict maximum agent invent"
    "ory\",\"type\":\"cyclus::toolkit::TotalInvTracker\",\"in"
    "dex\":36,\"shape\":[-"
    "1],\"alias\":\"inventory_tracker\",\"uilabel\":\"inventor"
    "y_tracker\"},\"latitude\":{\"default\":0.0,\"uilabel\":\"G"
    "eographical 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\":37,\"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\":38,\"shape\":[-"
    "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"}},\"do"
    "c\":\"Storage is a simple facility which accepts any"
    " number of commodities and holds them for a user "
    "specified amount of time. The commodities accepted"
    " are chosen based on the specified preferences "
    "list. Once the desired amount of material has "
    "entered the facility it is passed into a "
    "'processing' buffer where it is held until the "
    "residence time has passed. The material is then "
    "passed into a 'ready' buffer where it is queued "
    "for removal. Currently, all input commodities are "
    "lumped into a single output commodity. Storage "
    "also has the functionality to handle materials in "
    "discrete or continuous batches. Discrete mode, "
    "which is the default, does not split or combine "
    "material batches. Continuous mode, however, "
    "divides material batches if necessary in order to "
    "push materials through the facility as quickly as "
    "possible.\"}", root);
  if (!parsed_ok) {
    throw cyclus::ValueError("failed to parse annotations for cycamore::Storage.");
  }
  return root;
};
#line 23 "/cycamore/src/storage.cc"
 
void Storage::InitInv(cyclus::Inventories& inv) {
  inventory.Push(inv["inventory"]);
    stocks.Push(inv["stocks"]);
    ready.Push(inv["ready"]);
    processing.Push(inv["processing"]);
    ;
  
};
#line 25 "/cycamore/src/storage.cc"
 
cyclus::Inventories Storage::SnapshotInv() {
  cyclus::Inventories invs;
  invs["inventory"] = inventory.PopNRes(inventory.count());
  inventory.Push(invs["inventory"]);
  invs["stocks"] = stocks.PopNRes(stocks.count());
  stocks.Push(invs["stocks"]);
  invs["ready"] = ready.PopNRes(ready.count());
  ready.Push(invs["ready"]);
  invs["processing"] = processing.PopNRes(processing.count());
  processing.Push(invs["processing"]);
  ;
  return invs;
};
#line 27 "/cycamore/src/storage.cc"
 
void Storage::InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
  cyclus::Facility::InfileToDb(tree, di);
  int rawcycpp_shape_in_commods[2] = {-1, -1};
  cycpp_shape_in_commods = std::vector<int>(rawcycpp_shape_in_commods, rawcycpp_shape_in_commods + 2);
  int rawcycpp_shape_in_commod_prefs[2] = {-1, -1};
  cycpp_shape_in_commod_prefs = std::vector<int>(rawcycpp_shape_in_commod_prefs, rawcycpp_shape_in_commod_prefs + 2);
  int rawcycpp_shape_out_commods[2] = {-1, -1};
  cycpp_shape_out_commods = std::vector<int>(rawcycpp_shape_out_commods, rawcycpp_shape_out_commods + 2);
  int rawcycpp_shape_in_recipe[1] = {-1};
  cycpp_shape_in_recipe = std::vector<int>(rawcycpp_shape_in_recipe, rawcycpp_shape_in_recipe + 1);
  int rawcycpp_shape_residence_time[1] = {-1};
  cycpp_shape_residence_time = std::vector<int>(rawcycpp_shape_residence_time, rawcycpp_shape_residence_time + 1);
  int rawcycpp_shape_sell_quantity[1] = {-1};
  cycpp_shape_sell_quantity = std::vector<int>(rawcycpp_shape_sell_quantity, rawcycpp_shape_sell_quantity + 1);
  int rawcycpp_shape_throughput[1] = {-1};
  cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
  int rawcycpp_shape_max_inv_size[1] = {-1};
  cycpp_shape_max_inv_size = std::vector<int>(rawcycpp_shape_max_inv_size, rawcycpp_shape_max_inv_size + 1);
  int rawcycpp_shape_discrete_handling[1] = {-1};
  cycpp_shape_discrete_handling = std::vector<int>(rawcycpp_shape_discrete_handling, rawcycpp_shape_discrete_handling + 1);
  int rawcycpp_shape_active_buying_frequency_type[1] = {-1};
  cycpp_shape_active_buying_frequency_type = std::vector<int>(rawcycpp_shape_active_buying_frequency_type, rawcycpp_shape_active_buying_frequency_type + 1);
  int rawcycpp_shape_active_buying_val[1] = {-1};
  cycpp_shape_active_buying_val = std::vector<int>(rawcycpp_shape_active_buying_val, rawcycpp_shape_active_buying_val + 1);
  int rawcycpp_shape_active_buying_min[1] = {-1};
  cycpp_shape_active_buying_min = std::vector<int>(rawcycpp_shape_active_buying_min, rawcycpp_shape_active_buying_min + 1);
  int rawcycpp_shape_active_buying_max[1] = {-1};
  cycpp_shape_active_buying_max = std::vector<int>(rawcycpp_shape_active_buying_max, rawcycpp_shape_active_buying_max + 1);
  int rawcycpp_shape_active_buying_mean[1] = {-1};
  cycpp_shape_active_buying_mean = std::vector<int>(rawcycpp_shape_active_buying_mean, rawcycpp_shape_active_buying_mean + 1);
  int rawcycpp_shape_active_buying_stddev[1] = {-1};
  cycpp_shape_active_buying_stddev = std::vector<int>(rawcycpp_shape_active_buying_stddev, rawcycpp_shape_active_buying_stddev + 1);
  int rawcycpp_shape_dormant_buying_frequency_type[1] = {-1};
  cycpp_shape_dormant_buying_frequency_type = std::vector<int>(rawcycpp_shape_dormant_buying_frequency_type, rawcycpp_shape_dormant_buying_frequency_type + 1);
  int rawcycpp_shape_dormant_buying_val[1] = {-1};
  cycpp_shape_dormant_buying_val = std::vector<int>(rawcycpp_shape_dormant_buying_val, rawcycpp_shape_dormant_buying_val + 1);
  int rawcycpp_shape_dormant_buying_min[1] = {-1};
  cycpp_shape_dormant_buying_min = std::vector<int>(rawcycpp_shape_dormant_buying_min, rawcycpp_shape_dormant_buying_min + 1);
  int rawcycpp_shape_dormant_buying_max[1] = {-1};
  cycpp_shape_dormant_buying_max = std::vector<int>(rawcycpp_shape_dormant_buying_max, rawcycpp_shape_dormant_buying_max + 1);
  int rawcycpp_shape_dormant_buying_mean[1] = {-1};
  cycpp_shape_dormant_buying_mean = std::vector<int>(rawcycpp_shape_dormant_buying_mean, rawcycpp_shape_dormant_buying_mean + 1);
  int rawcycpp_shape_dormant_buying_stddev[1] = {-1};
  cycpp_shape_dormant_buying_stddev = std::vector<int>(rawcycpp_shape_dormant_buying_stddev, rawcycpp_shape_dormant_buying_stddev + 1);
  int rawcycpp_shape_buying_size_type[1] = {-1};
  cycpp_shape_buying_size_type = std::vector<int>(rawcycpp_shape_buying_size_type, rawcycpp_shape_buying_size_type + 1);
  int rawcycpp_shape_buying_size_val[1] = {-1};
  cycpp_shape_buying_size_val = std::vector<int>(rawcycpp_shape_buying_size_val, rawcycpp_shape_buying_size_val + 1);
  int rawcycpp_shape_buying_size_min[1] = {-1};
  cycpp_shape_buying_size_min = std::vector<int>(rawcycpp_shape_buying_size_min, rawcycpp_shape_buying_size_min + 1);
  int rawcycpp_shape_buying_size_max[1] = {-1};
  cycpp_shape_buying_size_max = std::vector<int>(rawcycpp_shape_buying_size_max, rawcycpp_shape_buying_size_max + 1);
  int rawcycpp_shape_buying_size_mean[1] = {-1};
  cycpp_shape_buying_size_mean = std::vector<int>(rawcycpp_shape_buying_size_mean, rawcycpp_shape_buying_size_mean + 1);
  int rawcycpp_shape_buying_size_stddev[1] = {-1};
  cycpp_shape_buying_size_stddev = std::vector<int>(rawcycpp_shape_buying_size_stddev, rawcycpp_shape_buying_size_stddev + 1);
  int rawcycpp_shape_reorder_point[1] = {-1};
  cycpp_shape_reorder_point = std::vector<int>(rawcycpp_shape_reorder_point, rawcycpp_shape_reorder_point + 1);
  int rawcycpp_shape_reorder_quantity[1] = {-1};
  cycpp_shape_reorder_quantity = std::vector<int>(rawcycpp_shape_reorder_quantity, rawcycpp_shape_reorder_quantity + 1);
  int rawcycpp_shape_cumulative_cap[1] = {-1};
  cycpp_shape_cumulative_cap = std::vector<int>(rawcycpp_shape_cumulative_cap, rawcycpp_shape_cumulative_cap + 1);
  int rawcycpp_shape_package[1] = {-1};
  cycpp_shape_package = std::vector<int>(rawcycpp_shape_package, rawcycpp_shape_package + 1);
  int rawcycpp_shape_transport_unit[1] = {-1};
  cycpp_shape_transport_unit = std::vector<int>(rawcycpp_shape_transport_unit, rawcycpp_shape_transport_unit + 1);
  int rawcycpp_shape_inventory[2] = {-1, -1};
  cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
  int rawcycpp_shape_stocks[2] = {-1, -1};
  cycpp_shape_stocks = std::vector<int>(rawcycpp_shape_stocks, rawcycpp_shape_stocks + 2);
  int rawcycpp_shape_ready[2] = {-1, -1};
  cycpp_shape_ready = std::vector<int>(rawcycpp_shape_ready, rawcycpp_shape_ready + 2);
  int rawcycpp_shape_processing[2] = {-1, -1};
  cycpp_shape_processing = std::vector<int>(rawcycpp_shape_processing, rawcycpp_shape_processing + 2);
  int rawcycpp_shape_inventory_tracker[1] = {-1};
  cycpp_shape_inventory_tracker = std::vector<int>(rawcycpp_shape_inventory_tracker, rawcycpp_shape_inventory_tracker + 1);
  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("in_commods", 0);
    cyclus::InfileTree* sub = bub;
    int n1 = sub->NMatches("val");
    std::vector< std::string > in_commods_val;
    in_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;
      }
      in_commods_val[i1] = elem;
    }
    in_commods = in_commods_val;
  }
  if (sub->NMatches("in_commod_prefs") > 0) {
    {
      cyclus::InfileTree* bub = sub->SubTree("in_commod_prefs", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< double > in_commod_prefs_val;
      in_commod_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;
        }
        in_commod_prefs_val[i1] = elem;
      }
      in_commod_prefs = in_commod_prefs_val;
    }
  } else {
    std::vector< double > in_commod_prefs_tmp;
    in_commod_prefs_tmp.resize(0);
    {
    }
    in_commod_prefs = in_commod_prefs_tmp;
  }
  {
    cyclus::InfileTree* bub = sub->SubTree("out_commods", 0);
    cyclus::InfileTree* sub = bub;
    int n1 = sub->NMatches("val");
    std::vector< std::string > out_commods_val;
    out_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;
      }
      out_commods_val[i1] = elem;
    }
    out_commods = out_commods_val;
  }
  if (sub->NMatches("in_recipe") > 0) {
    {
      std::string in_recipe_val = cyclus::Query<std::string>(sub, "in_recipe");
      in_recipe = in_recipe_val;
    }
  } else {
    std::string in_recipe_tmp("");
    in_recipe = in_recipe_tmp;
  }
  if (sub->NMatches("residence_time") > 0) {
    {
      int residence_time_val = cyclus::Query<int>(sub, "residence_time");
      residence_time = residence_time_val;
    }
  } else {
    int residence_time_tmp = 0;
    residence_time = residence_time_tmp;
  }
  if (sub->NMatches("sell_quantity") > 0) {
    {
      double sell_quantity_val = cyclus::Query<double>(sub, "sell_quantity");
      sell_quantity = sell_quantity_val;
    }
  } else {
    double sell_quantity_tmp = 0;
    sell_quantity = sell_quantity_tmp;
  }
  if (sub->NMatches("throughput") > 0) {
    {
      double throughput_val = cyclus::Query<double>(sub, "throughput");
      throughput = throughput_val;
    }
  } else {
    double throughput_tmp = 1e+299;
    throughput = throughput_tmp;
  }
  if (sub->NMatches("max_inv_size") > 0) {
    {
      double max_inv_size_val = cyclus::Query<double>(sub, "max_inv_size");
      max_inv_size = max_inv_size_val;
    }
  } else {
    double max_inv_size_tmp = 1e+299;
    max_inv_size = max_inv_size_tmp;
  }
  if (sub->NMatches("discrete_handling") > 0) {
    {
      bool discrete_handling_val = cyclus::Query<bool>(sub, "discrete_handling");
      discrete_handling = discrete_handling_val;
    }
  } else {
    bool discrete_handling_tmp = false;
    discrete_handling = discrete_handling_tmp;
  }
  if (sub->NMatches("active_buying_frequency_type") > 0) {
    {
      std::string active_buying_frequency_type_val = cyclus::Query<std::string>(sub, "active_buying_frequency_type");
      active_buying_frequency_type = active_buying_frequency_type_val;
    }
  } else {
    std::string active_buying_frequency_type_tmp("Fixed");
    active_buying_frequency_type = active_buying_frequency_type_tmp;
  }
  if (sub->NMatches("active_buying_val") > 0) {
    {
      int active_buying_val_val = cyclus::Query<int>(sub, "active_buying_val");
      active_buying_val = active_buying_val_val;
    }
  } else {
    int active_buying_val_tmp = -1;
    active_buying_val = active_buying_val_tmp;
  }
  if (sub->NMatches("active_buying_min") > 0) {
    {
      int active_buying_min_val = cyclus::Query<int>(sub, "active_buying_min");
      active_buying_min = active_buying_min_val;
    }
  } else {
    int active_buying_min_tmp = -1;
    active_buying_min = active_buying_min_tmp;
  }
  if (sub->NMatches("active_buying_max") > 0) {
    {
      int active_buying_max_val = cyclus::Query<int>(sub, "active_buying_max");
      active_buying_max = active_buying_max_val;
    }
  } else {
    int active_buying_max_tmp = -1;
    active_buying_max = active_buying_max_tmp;
  }
  if (sub->NMatches("active_buying_mean") > 0) {
    {
      double active_buying_mean_val = cyclus::Query<double>(sub, "active_buying_mean");
      active_buying_mean = active_buying_mean_val;
    }
  } else {
    double active_buying_mean_tmp = -1;
    active_buying_mean = active_buying_mean_tmp;
  }
  if (sub->NMatches("active_buying_stddev") > 0) {
    {
      double active_buying_stddev_val = cyclus::Query<double>(sub, "active_buying_stddev");
      active_buying_stddev = active_buying_stddev_val;
    }
  } else {
    double active_buying_stddev_tmp = -1;
    active_buying_stddev = active_buying_stddev_tmp;
  }
  if (sub->NMatches("dormant_buying_frequency_type") > 0) {
    {
      std::string dormant_buying_frequency_type_val = cyclus::Query<std::string>(sub, "dormant_buying_frequency_type");
      dormant_buying_frequency_type = dormant_buying_frequency_type_val;
    }
  } else {
    std::string dormant_buying_frequency_type_tmp("Fixed");
    dormant_buying_frequency_type = dormant_buying_frequency_type_tmp;
  }
  if (sub->NMatches("dormant_buying_val") > 0) {
    {
      int dormant_buying_val_val = cyclus::Query<int>(sub, "dormant_buying_val");
      dormant_buying_val = dormant_buying_val_val;
    }
  } else {
    int dormant_buying_val_tmp = -1;
    dormant_buying_val = dormant_buying_val_tmp;
  }
  if (sub->NMatches("dormant_buying_min") > 0) {
    {
      int dormant_buying_min_val = cyclus::Query<int>(sub, "dormant_buying_min");
      dormant_buying_min = dormant_buying_min_val;
    }
  } else {
    int dormant_buying_min_tmp = -1;
    dormant_buying_min = dormant_buying_min_tmp;
  }
  if (sub->NMatches("dormant_buying_max") > 0) {
    {
      int dormant_buying_max_val = cyclus::Query<int>(sub, "dormant_buying_max");
      dormant_buying_max = dormant_buying_max_val;
    }
  } else {
    int dormant_buying_max_tmp = -1;
    dormant_buying_max = dormant_buying_max_tmp;
  }
  if (sub->NMatches("dormant_buying_mean") > 0) {
    {
      double dormant_buying_mean_val = cyclus::Query<double>(sub, "dormant_buying_mean");
      dormant_buying_mean = dormant_buying_mean_val;
    }
  } else {
    double dormant_buying_mean_tmp = -1;
    dormant_buying_mean = dormant_buying_mean_tmp;
  }
  if (sub->NMatches("dormant_buying_stddev") > 0) {
    {
      double dormant_buying_stddev_val = cyclus::Query<double>(sub, "dormant_buying_stddev");
      dormant_buying_stddev = dormant_buying_stddev_val;
    }
  } else {
    double dormant_buying_stddev_tmp = -1;
    dormant_buying_stddev = dormant_buying_stddev_tmp;
  }
  if (sub->NMatches("buying_size_type") > 0) {
    {
      std::string buying_size_type_val = cyclus::Query<std::string>(sub, "buying_size_type");
      buying_size_type = buying_size_type_val;
    }
  } else {
    std::string buying_size_type_tmp("Fixed");
    buying_size_type = buying_size_type_tmp;
  }
  if (sub->NMatches("buying_size_val") > 0) {
    {
      double buying_size_val_val = cyclus::Query<double>(sub, "buying_size_val");
      buying_size_val = buying_size_val_val;
    }
  } else {
    double buying_size_val_tmp = 1.0;
    buying_size_val = buying_size_val_tmp;
  }
  if (sub->NMatches("buying_size_min") > 0) {
    {
      double buying_size_min_val = cyclus::Query<double>(sub, "buying_size_min");
      buying_size_min = buying_size_min_val;
    }
  } else {
    double buying_size_min_tmp = -1.0;
    buying_size_min = buying_size_min_tmp;
  }
  if (sub->NMatches("buying_size_max") > 0) {
    {
      double buying_size_max_val = cyclus::Query<double>(sub, "buying_size_max");
      buying_size_max = buying_size_max_val;
    }
  } else {
    double buying_size_max_tmp = -1.0;
    buying_size_max = buying_size_max_tmp;
  }
  if (sub->NMatches("buying_size_mean") > 0) {
    {
      double buying_size_mean_val = cyclus::Query<double>(sub, "buying_size_mean");
      buying_size_mean = buying_size_mean_val;
    }
  } else {
    double buying_size_mean_tmp = -1.0;
    buying_size_mean = buying_size_mean_tmp;
  }
  if (sub->NMatches("buying_size_stddev") > 0) {
    {
      double buying_size_stddev_val = cyclus::Query<double>(sub, "buying_size_stddev");
      buying_size_stddev = buying_size_stddev_val;
    }
  } else {
    double buying_size_stddev_tmp = -1.0;
    buying_size_stddev = buying_size_stddev_tmp;
  }
  if (sub->NMatches("reorder_point") > 0) {
    {
      double reorder_point_val = cyclus::Query<double>(sub, "reorder_point");
      reorder_point = reorder_point_val;
    }
  } else {
    double reorder_point_tmp = -1;
    reorder_point = reorder_point_tmp;
  }
  if (sub->NMatches("reorder_quantity") > 0) {
    {
      double reorder_quantity_val = cyclus::Query<double>(sub, "reorder_quantity");
      reorder_quantity = reorder_quantity_val;
    }
  } else {
    double reorder_quantity_tmp = -1;
    reorder_quantity = reorder_quantity_tmp;
  }
  if (sub->NMatches("cumulative_cap") > 0) {
    {
      double cumulative_cap_val = cyclus::Query<double>(sub, "cumulative_cap");
      cumulative_cap = cumulative_cap_val;
    }
  } else {
    double cumulative_cap_tmp = -1;
    cumulative_cap = cumulative_cap_tmp;
  }
  if (sub->NMatches("package") > 0) {
    {
      std::string package_val = cyclus::Query<std::string>(sub, "package");
      package = package_val;
    }
  } else {
    std::string package_tmp("unpackaged");
    package = package_tmp;
  }
  if (sub->NMatches("transport_unit") > 0) {
    {
      std::string transport_unit_val = cyclus::Query<std::string>(sub, "transport_unit");
      transport_unit = transport_unit_val;
    }
  } else {
    std::string transport_unit_tmp("unrestricted");
    transport_unit = transport_unit_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("in_commods", in_commods, &cycpp_shape_in_commods)
  ->AddVal("in_commod_prefs", in_commod_prefs, &cycpp_shape_in_commod_prefs)
  ->AddVal("out_commods", out_commods, &cycpp_shape_out_commods)
  ->AddVal("in_recipe", in_recipe, &cycpp_shape_in_recipe)
  ->AddVal("residence_time", residence_time, &cycpp_shape_residence_time)
  ->AddVal("sell_quantity", sell_quantity, &cycpp_shape_sell_quantity)
  ->AddVal("throughput", throughput, &cycpp_shape_throughput)
  ->AddVal("max_inv_size", max_inv_size, &cycpp_shape_max_inv_size)
  ->AddVal("discrete_handling", discrete_handling, &cycpp_shape_discrete_handling)
  ->AddVal("active_buying_frequency_type", active_buying_frequency_type, &cycpp_shape_active_buying_frequency_type)
  ->AddVal("active_buying_val", active_buying_val, &cycpp_shape_active_buying_val)
  ->AddVal("active_buying_min", active_buying_min, &cycpp_shape_active_buying_min)
  ->AddVal("active_buying_max", active_buying_max, &cycpp_shape_active_buying_max)
  ->AddVal("active_buying_mean", active_buying_mean, &cycpp_shape_active_buying_mean)
  ->AddVal("active_buying_stddev", active_buying_stddev, &cycpp_shape_active_buying_stddev)
  ->AddVal("dormant_buying_frequency_type", dormant_buying_frequency_type, &cycpp_shape_dormant_buying_frequency_type)
  ->AddVal("dormant_buying_val", dormant_buying_val, &cycpp_shape_dormant_buying_val)
  ->AddVal("dormant_buying_min", dormant_buying_min, &cycpp_shape_dormant_buying_min)
  ->AddVal("dormant_buying_max", dormant_buying_max, &cycpp_shape_dormant_buying_max)
  ->AddVal("dormant_buying_mean", dormant_buying_mean, &cycpp_shape_dormant_buying_mean)
  ->AddVal("dormant_buying_stddev", dormant_buying_stddev, &cycpp_shape_dormant_buying_stddev)
  ->AddVal("buying_size_type", buying_size_type, &cycpp_shape_buying_size_type)
  ->AddVal("buying_size_val", buying_size_val, &cycpp_shape_buying_size_val)
  ->AddVal("buying_size_min", buying_size_min, &cycpp_shape_buying_size_min)
  ->AddVal("buying_size_max", buying_size_max, &cycpp_shape_buying_size_max)
  ->AddVal("buying_size_mean", buying_size_mean, &cycpp_shape_buying_size_mean)
  ->AddVal("buying_size_stddev", buying_size_stddev, &cycpp_shape_buying_size_stddev)
  ->AddVal("reorder_point", reorder_point, &cycpp_shape_reorder_point)
  ->AddVal("reorder_quantity", reorder_quantity, &cycpp_shape_reorder_quantity)
  ->AddVal("cumulative_cap", cumulative_cap, &cycpp_shape_cumulative_cap)
  ->AddVal("package", package, &cycpp_shape_package)
  ->AddVal("transport_unit", transport_unit, &cycpp_shape_transport_unit)
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->Record();
};
#line 29 "/cycamore/src/storage.cc"
 
void Storage::Snapshot(cyclus::DbInit di) {
  di.NewDatum("Info")
  ->AddVal("in_commods", in_commods, &cycpp_shape_in_commods)
  ->AddVal("in_commod_prefs", in_commod_prefs, &cycpp_shape_in_commod_prefs)
  ->AddVal("out_commods", out_commods, &cycpp_shape_out_commods)
  ->AddVal("in_recipe", in_recipe, &cycpp_shape_in_recipe)
  ->AddVal("residence_time", residence_time, &cycpp_shape_residence_time)
  ->AddVal("sell_quantity", sell_quantity, &cycpp_shape_sell_quantity)
  ->AddVal("throughput", throughput, &cycpp_shape_throughput)
  ->AddVal("max_inv_size", max_inv_size, &cycpp_shape_max_inv_size)
  ->AddVal("discrete_handling", discrete_handling, &cycpp_shape_discrete_handling)
  ->AddVal("active_buying_frequency_type", active_buying_frequency_type, &cycpp_shape_active_buying_frequency_type)
  ->AddVal("active_buying_val", active_buying_val, &cycpp_shape_active_buying_val)
  ->AddVal("active_buying_min", active_buying_min, &cycpp_shape_active_buying_min)
  ->AddVal("active_buying_max", active_buying_max, &cycpp_shape_active_buying_max)
  ->AddVal("active_buying_mean", active_buying_mean, &cycpp_shape_active_buying_mean)
  ->AddVal("active_buying_stddev", active_buying_stddev, &cycpp_shape_active_buying_stddev)
  ->AddVal("dormant_buying_frequency_type", dormant_buying_frequency_type, &cycpp_shape_dormant_buying_frequency_type)
  ->AddVal("dormant_buying_val", dormant_buying_val, &cycpp_shape_dormant_buying_val)
  ->AddVal("dormant_buying_min", dormant_buying_min, &cycpp_shape_dormant_buying_min)
  ->AddVal("dormant_buying_max", dormant_buying_max, &cycpp_shape_dormant_buying_max)
  ->AddVal("dormant_buying_mean", dormant_buying_mean, &cycpp_shape_dormant_buying_mean)
  ->AddVal("dormant_buying_stddev", dormant_buying_stddev, &cycpp_shape_dormant_buying_stddev)
  ->AddVal("buying_size_type", buying_size_type, &cycpp_shape_buying_size_type)
  ->AddVal("buying_size_val", buying_size_val, &cycpp_shape_buying_size_val)
  ->AddVal("buying_size_min", buying_size_min, &cycpp_shape_buying_size_min)
  ->AddVal("buying_size_max", buying_size_max, &cycpp_shape_buying_size_max)
  ->AddVal("buying_size_mean", buying_size_mean, &cycpp_shape_buying_size_mean)
  ->AddVal("buying_size_stddev", buying_size_stddev, &cycpp_shape_buying_size_stddev)
  ->AddVal("reorder_point", reorder_point, &cycpp_shape_reorder_point)
  ->AddVal("reorder_quantity", reorder_quantity, &cycpp_shape_reorder_quantity)
  ->AddVal("cumulative_cap", cumulative_cap, &cycpp_shape_cumulative_cap)
  ->AddVal("package", package, &cycpp_shape_package)
  ->AddVal("transport_unit", transport_unit, &cycpp_shape_transport_unit)
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->Record();
};
#line 31 "/cycamore/src/storage.cc"
 
cyclus::Agent* Storage::Clone() {
  cycamore::Storage* m = new cycamore::Storage(context());
  m->InitFrom(this);
  return m;
};
#line 33 "/cycamore/src/storage.cc"
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::InitFrom(Storage* m) {    cyclus::Facility::InitFrom(m);
    int rawcycpp_shape_in_commods[2] = {-1, -1};
    cycpp_shape_in_commods = std::vector<int>(rawcycpp_shape_in_commods, rawcycpp_shape_in_commods + 2);
    int rawcycpp_shape_in_commod_prefs[2] = {-1, -1};
    cycpp_shape_in_commod_prefs = std::vector<int>(rawcycpp_shape_in_commod_prefs, rawcycpp_shape_in_commod_prefs + 2);
    int rawcycpp_shape_out_commods[2] = {-1, -1};
    cycpp_shape_out_commods = std::vector<int>(rawcycpp_shape_out_commods, rawcycpp_shape_out_commods + 2);
    int rawcycpp_shape_in_recipe[1] = {-1};
    cycpp_shape_in_recipe = std::vector<int>(rawcycpp_shape_in_recipe, rawcycpp_shape_in_recipe + 1);
    int rawcycpp_shape_residence_time[1] = {-1};
    cycpp_shape_residence_time = std::vector<int>(rawcycpp_shape_residence_time, rawcycpp_shape_residence_time + 1);
    int rawcycpp_shape_sell_quantity[1] = {-1};
    cycpp_shape_sell_quantity = std::vector<int>(rawcycpp_shape_sell_quantity, rawcycpp_shape_sell_quantity + 1);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_max_inv_size[1] = {-1};
    cycpp_shape_max_inv_size = std::vector<int>(rawcycpp_shape_max_inv_size, rawcycpp_shape_max_inv_size + 1);
    int rawcycpp_shape_discrete_handling[1] = {-1};
    cycpp_shape_discrete_handling = std::vector<int>(rawcycpp_shape_discrete_handling, rawcycpp_shape_discrete_handling + 1);
    int rawcycpp_shape_active_buying_frequency_type[1] = {-1};
    cycpp_shape_active_buying_frequency_type = std::vector<int>(rawcycpp_shape_active_buying_frequency_type, rawcycpp_shape_active_buying_frequency_type + 1);
    int rawcycpp_shape_active_buying_val[1] = {-1};
    cycpp_shape_active_buying_val = std::vector<int>(rawcycpp_shape_active_buying_val, rawcycpp_shape_active_buying_val + 1);
    int rawcycpp_shape_active_buying_min[1] = {-1};
    cycpp_shape_active_buying_min = std::vector<int>(rawcycpp_shape_active_buying_min, rawcycpp_shape_active_buying_min + 1);
    int rawcycpp_shape_active_buying_max[1] = {-1};
    cycpp_shape_active_buying_max = std::vector<int>(rawcycpp_shape_active_buying_max, rawcycpp_shape_active_buying_max + 1);
    int rawcycpp_shape_active_buying_mean[1] = {-1};
    cycpp_shape_active_buying_mean = std::vector<int>(rawcycpp_shape_active_buying_mean, rawcycpp_shape_active_buying_mean + 1);
    int rawcycpp_shape_active_buying_stddev[1] = {-1};
    cycpp_shape_active_buying_stddev = std::vector<int>(rawcycpp_shape_active_buying_stddev, rawcycpp_shape_active_buying_stddev + 1);
    int rawcycpp_shape_dormant_buying_frequency_type[1] = {-1};
    cycpp_shape_dormant_buying_frequency_type = std::vector<int>(rawcycpp_shape_dormant_buying_frequency_type, rawcycpp_shape_dormant_buying_frequency_type + 1);
    int rawcycpp_shape_dormant_buying_val[1] = {-1};
    cycpp_shape_dormant_buying_val = std::vector<int>(rawcycpp_shape_dormant_buying_val, rawcycpp_shape_dormant_buying_val + 1);
    int rawcycpp_shape_dormant_buying_min[1] = {-1};
    cycpp_shape_dormant_buying_min = std::vector<int>(rawcycpp_shape_dormant_buying_min, rawcycpp_shape_dormant_buying_min + 1);
    int rawcycpp_shape_dormant_buying_max[1] = {-1};
    cycpp_shape_dormant_buying_max = std::vector<int>(rawcycpp_shape_dormant_buying_max, rawcycpp_shape_dormant_buying_max + 1);
    int rawcycpp_shape_dormant_buying_mean[1] = {-1};
    cycpp_shape_dormant_buying_mean = std::vector<int>(rawcycpp_shape_dormant_buying_mean, rawcycpp_shape_dormant_buying_mean + 1);
    int rawcycpp_shape_dormant_buying_stddev[1] = {-1};
    cycpp_shape_dormant_buying_stddev = std::vector<int>(rawcycpp_shape_dormant_buying_stddev, rawcycpp_shape_dormant_buying_stddev + 1);
    int rawcycpp_shape_buying_size_type[1] = {-1};
    cycpp_shape_buying_size_type = std::vector<int>(rawcycpp_shape_buying_size_type, rawcycpp_shape_buying_size_type + 1);
    int rawcycpp_shape_buying_size_val[1] = {-1};
    cycpp_shape_buying_size_val = std::vector<int>(rawcycpp_shape_buying_size_val, rawcycpp_shape_buying_size_val + 1);
    int rawcycpp_shape_buying_size_min[1] = {-1};
    cycpp_shape_buying_size_min = std::vector<int>(rawcycpp_shape_buying_size_min, rawcycpp_shape_buying_size_min + 1);
    int rawcycpp_shape_buying_size_max[1] = {-1};
    cycpp_shape_buying_size_max = std::vector<int>(rawcycpp_shape_buying_size_max, rawcycpp_shape_buying_size_max + 1);
    int rawcycpp_shape_buying_size_mean[1] = {-1};
    cycpp_shape_buying_size_mean = std::vector<int>(rawcycpp_shape_buying_size_mean, rawcycpp_shape_buying_size_mean + 1);
    int rawcycpp_shape_buying_size_stddev[1] = {-1};
    cycpp_shape_buying_size_stddev = std::vector<int>(rawcycpp_shape_buying_size_stddev, rawcycpp_shape_buying_size_stddev + 1);
    int rawcycpp_shape_reorder_point[1] = {-1};
    cycpp_shape_reorder_point = std::vector<int>(rawcycpp_shape_reorder_point, rawcycpp_shape_reorder_point + 1);
    int rawcycpp_shape_reorder_quantity[1] = {-1};
    cycpp_shape_reorder_quantity = std::vector<int>(rawcycpp_shape_reorder_quantity, rawcycpp_shape_reorder_quantity + 1);
    int rawcycpp_shape_cumulative_cap[1] = {-1};
    cycpp_shape_cumulative_cap = std::vector<int>(rawcycpp_shape_cumulative_cap, rawcycpp_shape_cumulative_cap + 1);
    int rawcycpp_shape_package[1] = {-1};
    cycpp_shape_package = std::vector<int>(rawcycpp_shape_package, rawcycpp_shape_package + 1);
    int rawcycpp_shape_transport_unit[1] = {-1};
    cycpp_shape_transport_unit = std::vector<int>(rawcycpp_shape_transport_unit, rawcycpp_shape_transport_unit + 1);
    int rawcycpp_shape_inventory[2] = {-1, -1};
    cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
    int rawcycpp_shape_stocks[2] = {-1, -1};
    cycpp_shape_stocks = std::vector<int>(rawcycpp_shape_stocks, rawcycpp_shape_stocks + 2);
    int rawcycpp_shape_ready[2] = {-1, -1};
    cycpp_shape_ready = std::vector<int>(rawcycpp_shape_ready, rawcycpp_shape_ready + 2);
    int rawcycpp_shape_processing[2] = {-1, -1};
    cycpp_shape_processing = std::vector<int>(rawcycpp_shape_processing, rawcycpp_shape_processing + 2);
    int rawcycpp_shape_inventory_tracker[1] = {-1};
    cycpp_shape_inventory_tracker = std::vector<int>(rawcycpp_shape_inventory_tracker, rawcycpp_shape_inventory_tracker + 1);
    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);
    in_commods = m->in_commods;
    in_commod_prefs = m->in_commod_prefs;
    out_commods = m->out_commods;
    in_recipe = m->in_recipe;
    residence_time = m->residence_time;
    sell_quantity = m->sell_quantity;
    throughput = m->throughput;
    max_inv_size = m->max_inv_size;
    discrete_handling = m->discrete_handling;
    active_buying_frequency_type = m->active_buying_frequency_type;
    active_buying_val = m->active_buying_val;
    active_buying_min = m->active_buying_min;
    active_buying_max = m->active_buying_max;
    active_buying_mean = m->active_buying_mean;
    active_buying_stddev = m->active_buying_stddev;
    dormant_buying_frequency_type = m->dormant_buying_frequency_type;
    dormant_buying_val = m->dormant_buying_val;
    dormant_buying_min = m->dormant_buying_min;
    dormant_buying_max = m->dormant_buying_max;
    dormant_buying_mean = m->dormant_buying_mean;
    dormant_buying_stddev = m->dormant_buying_stddev;
    buying_size_type = m->buying_size_type;
    buying_size_val = m->buying_size_val;
    buying_size_min = m->buying_size_min;
    buying_size_max = m->buying_size_max;
    buying_size_mean = m->buying_size_mean;
    buying_size_stddev = m->buying_size_stddev;
    reorder_point = m->reorder_point;
    reorder_quantity = m->reorder_quantity;
    cumulative_cap = m->cumulative_cap;
    package = m->package;
    transport_unit = m->transport_unit;
    latitude = m->latitude;
    longitude = m->longitude;
    inventory.capacity(m->inventory.capacity());
    stocks.capacity(m->stocks.capacity());
    ready.capacity(m->ready.capacity());
    processing.capacity(m->processing.capacity());
    inventory_tracker.capacity();
#line 37 "/cycamore/src/storage.cc"
  cyclus::toolkit::CommodityProducer::Copy(m);
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::InitFrom(cyclus::QueryableBackend* b) {    cyclus::Facility::InitFrom(b);
    int rawcycpp_shape_in_commods[2] = {-1, -1};
    cycpp_shape_in_commods = std::vector<int>(rawcycpp_shape_in_commods, rawcycpp_shape_in_commods + 2);
    int rawcycpp_shape_in_commod_prefs[2] = {-1, -1};
    cycpp_shape_in_commod_prefs = std::vector<int>(rawcycpp_shape_in_commod_prefs, rawcycpp_shape_in_commod_prefs + 2);
    int rawcycpp_shape_out_commods[2] = {-1, -1};
    cycpp_shape_out_commods = std::vector<int>(rawcycpp_shape_out_commods, rawcycpp_shape_out_commods + 2);
    int rawcycpp_shape_in_recipe[1] = {-1};
    cycpp_shape_in_recipe = std::vector<int>(rawcycpp_shape_in_recipe, rawcycpp_shape_in_recipe + 1);
    int rawcycpp_shape_residence_time[1] = {-1};
    cycpp_shape_residence_time = std::vector<int>(rawcycpp_shape_residence_time, rawcycpp_shape_residence_time + 1);
    int rawcycpp_shape_sell_quantity[1] = {-1};
    cycpp_shape_sell_quantity = std::vector<int>(rawcycpp_shape_sell_quantity, rawcycpp_shape_sell_quantity + 1);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_max_inv_size[1] = {-1};
    cycpp_shape_max_inv_size = std::vector<int>(rawcycpp_shape_max_inv_size, rawcycpp_shape_max_inv_size + 1);
    int rawcycpp_shape_discrete_handling[1] = {-1};
    cycpp_shape_discrete_handling = std::vector<int>(rawcycpp_shape_discrete_handling, rawcycpp_shape_discrete_handling + 1);
    int rawcycpp_shape_active_buying_frequency_type[1] = {-1};
    cycpp_shape_active_buying_frequency_type = std::vector<int>(rawcycpp_shape_active_buying_frequency_type, rawcycpp_shape_active_buying_frequency_type + 1);
    int rawcycpp_shape_active_buying_val[1] = {-1};
    cycpp_shape_active_buying_val = std::vector<int>(rawcycpp_shape_active_buying_val, rawcycpp_shape_active_buying_val + 1);
    int rawcycpp_shape_active_buying_min[1] = {-1};
    cycpp_shape_active_buying_min = std::vector<int>(rawcycpp_shape_active_buying_min, rawcycpp_shape_active_buying_min + 1);
    int rawcycpp_shape_active_buying_max[1] = {-1};
    cycpp_shape_active_buying_max = std::vector<int>(rawcycpp_shape_active_buying_max, rawcycpp_shape_active_buying_max + 1);
    int rawcycpp_shape_active_buying_mean[1] = {-1};
    cycpp_shape_active_buying_mean = std::vector<int>(rawcycpp_shape_active_buying_mean, rawcycpp_shape_active_buying_mean + 1);
    int rawcycpp_shape_active_buying_stddev[1] = {-1};
    cycpp_shape_active_buying_stddev = std::vector<int>(rawcycpp_shape_active_buying_stddev, rawcycpp_shape_active_buying_stddev + 1);
    int rawcycpp_shape_dormant_buying_frequency_type[1] = {-1};
    cycpp_shape_dormant_buying_frequency_type = std::vector<int>(rawcycpp_shape_dormant_buying_frequency_type, rawcycpp_shape_dormant_buying_frequency_type + 1);
    int rawcycpp_shape_dormant_buying_val[1] = {-1};
    cycpp_shape_dormant_buying_val = std::vector<int>(rawcycpp_shape_dormant_buying_val, rawcycpp_shape_dormant_buying_val + 1);
    int rawcycpp_shape_dormant_buying_min[1] = {-1};
    cycpp_shape_dormant_buying_min = std::vector<int>(rawcycpp_shape_dormant_buying_min, rawcycpp_shape_dormant_buying_min + 1);
    int rawcycpp_shape_dormant_buying_max[1] = {-1};
    cycpp_shape_dormant_buying_max = std::vector<int>(rawcycpp_shape_dormant_buying_max, rawcycpp_shape_dormant_buying_max + 1);
    int rawcycpp_shape_dormant_buying_mean[1] = {-1};
    cycpp_shape_dormant_buying_mean = std::vector<int>(rawcycpp_shape_dormant_buying_mean, rawcycpp_shape_dormant_buying_mean + 1);
    int rawcycpp_shape_dormant_buying_stddev[1] = {-1};
    cycpp_shape_dormant_buying_stddev = std::vector<int>(rawcycpp_shape_dormant_buying_stddev, rawcycpp_shape_dormant_buying_stddev + 1);
    int rawcycpp_shape_buying_size_type[1] = {-1};
    cycpp_shape_buying_size_type = std::vector<int>(rawcycpp_shape_buying_size_type, rawcycpp_shape_buying_size_type + 1);
    int rawcycpp_shape_buying_size_val[1] = {-1};
    cycpp_shape_buying_size_val = std::vector<int>(rawcycpp_shape_buying_size_val, rawcycpp_shape_buying_size_val + 1);
    int rawcycpp_shape_buying_size_min[1] = {-1};
    cycpp_shape_buying_size_min = std::vector<int>(rawcycpp_shape_buying_size_min, rawcycpp_shape_buying_size_min + 1);
    int rawcycpp_shape_buying_size_max[1] = {-1};
    cycpp_shape_buying_size_max = std::vector<int>(rawcycpp_shape_buying_size_max, rawcycpp_shape_buying_size_max + 1);
    int rawcycpp_shape_buying_size_mean[1] = {-1};
    cycpp_shape_buying_size_mean = std::vector<int>(rawcycpp_shape_buying_size_mean, rawcycpp_shape_buying_size_mean + 1);
    int rawcycpp_shape_buying_size_stddev[1] = {-1};
    cycpp_shape_buying_size_stddev = std::vector<int>(rawcycpp_shape_buying_size_stddev, rawcycpp_shape_buying_size_stddev + 1);
    int rawcycpp_shape_reorder_point[1] = {-1};
    cycpp_shape_reorder_point = std::vector<int>(rawcycpp_shape_reorder_point, rawcycpp_shape_reorder_point + 1);
    int rawcycpp_shape_reorder_quantity[1] = {-1};
    cycpp_shape_reorder_quantity = std::vector<int>(rawcycpp_shape_reorder_quantity, rawcycpp_shape_reorder_quantity + 1);
    int rawcycpp_shape_cumulative_cap[1] = {-1};
    cycpp_shape_cumulative_cap = std::vector<int>(rawcycpp_shape_cumulative_cap, rawcycpp_shape_cumulative_cap + 1);
    int rawcycpp_shape_package[1] = {-1};
    cycpp_shape_package = std::vector<int>(rawcycpp_shape_package, rawcycpp_shape_package + 1);
    int rawcycpp_shape_transport_unit[1] = {-1};
    cycpp_shape_transport_unit = std::vector<int>(rawcycpp_shape_transport_unit, rawcycpp_shape_transport_unit + 1);
    int rawcycpp_shape_inventory[2] = {-1, -1};
    cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
    int rawcycpp_shape_stocks[2] = {-1, -1};
    cycpp_shape_stocks = std::vector<int>(rawcycpp_shape_stocks, rawcycpp_shape_stocks + 2);
    int rawcycpp_shape_ready[2] = {-1, -1};
    cycpp_shape_ready = std::vector<int>(rawcycpp_shape_ready, rawcycpp_shape_ready + 2);
    int rawcycpp_shape_processing[2] = {-1, -1};
    cycpp_shape_processing = std::vector<int>(rawcycpp_shape_processing, rawcycpp_shape_processing + 2);
    int rawcycpp_shape_inventory_tracker[1] = {-1};
    cycpp_shape_inventory_tracker = std::vector<int>(rawcycpp_shape_inventory_tracker, rawcycpp_shape_inventory_tracker + 1);
    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);
    in_commods = qr.GetVal<std::vector< std::string > >("in_commods");
    in_commod_prefs = qr.GetVal<std::vector< double > >("in_commod_prefs");
    out_commods = qr.GetVal<std::vector< std::string > >("out_commods");
    in_recipe = qr.GetVal<std::string>("in_recipe");
    residence_time = qr.GetVal<int>("residence_time");
    sell_quantity = qr.GetVal<double>("sell_quantity");
    throughput = qr.GetVal<double>("throughput");
    max_inv_size = qr.GetVal<double>("max_inv_size");
    discrete_handling = qr.GetVal<bool>("discrete_handling");
    active_buying_frequency_type = qr.GetVal<std::string>("active_buying_frequency_type");
    active_buying_val = qr.GetVal<int>("active_buying_val");
    active_buying_min = qr.GetVal<int>("active_buying_min");
    active_buying_max = qr.GetVal<int>("active_buying_max");
    active_buying_mean = qr.GetVal<double>("active_buying_mean");
    active_buying_stddev = qr.GetVal<double>("active_buying_stddev");
    dormant_buying_frequency_type = qr.GetVal<std::string>("dormant_buying_frequency_type");
    dormant_buying_val = qr.GetVal<int>("dormant_buying_val");
    dormant_buying_min = qr.GetVal<int>("dormant_buying_min");
    dormant_buying_max = qr.GetVal<int>("dormant_buying_max");
    dormant_buying_mean = qr.GetVal<double>("dormant_buying_mean");
    dormant_buying_stddev = qr.GetVal<double>("dormant_buying_stddev");
    buying_size_type = qr.GetVal<std::string>("buying_size_type");
    buying_size_val = qr.GetVal<double>("buying_size_val");
    buying_size_min = qr.GetVal<double>("buying_size_min");
    buying_size_max = qr.GetVal<double>("buying_size_max");
    buying_size_mean = qr.GetVal<double>("buying_size_mean");
    buying_size_stddev = qr.GetVal<double>("buying_size_stddev");
    reorder_point = qr.GetVal<double>("reorder_point");
    reorder_quantity = qr.GetVal<double>("reorder_quantity");
    cumulative_cap = qr.GetVal<double>("cumulative_cap");
    package = qr.GetVal<std::string>("package");
    transport_unit = qr.GetVal<std::string>("transport_unit");
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
    inventory.capacity(1e+300);
    stocks.capacity(1e+300);
    ready.capacity(1e+300);
    processing.capacity(1e+300);
    inventory_tracker.capacity();
#line 43 "/cycamore/src/storage.cc"
 
  cyclus::toolkit::Commodity commod = cyclus::toolkit::Commodity(out_commods.front());
  cyclus::toolkit::CommodityProducer::Add(commod);
  cyclus::toolkit::CommodityProducer::SetCapacity(commod, throughput);
}
 
void Storage::InitBuyPolicyParameters() {
  if (active_buying_min > active_buying_max) {
    throw cyclus::ValueError("Active min larger than max.");
  }
  if (dormant_buying_min > dormant_buying_max) {
    throw cyclus::ValueError("Dormant min larger than max.");
  }
  if (buying_size_min > buying_size_max) {
    throw cyclus::ValueError("Buying size min larger than max.");
  }
 
  if (active_buying_frequency_type == "Fixed") {
    active_dist_ = cyclus::FixedIntDist::Ptr (new cyclus::FixedIntDist(active_buying_val));
  }
  else if (active_buying_frequency_type == "Uniform") {
    if ((active_buying_min == -1) || (active_buying_max == -1)) {
      throw cyclus::ValueError("Invalid active buying frequency range. Please provide both a min and max value.");
    }
    active_dist_ = cyclus::UniformIntDist::Ptr (new cyclus::UniformIntDist(active_buying_min, active_buying_max));
  }
  else if (active_buying_frequency_type == "Normal") {
    if ((active_buying_mean == -1) || (active_buying_stddev == -1)) {
      throw cyclus::ValueError("Invalid active buying frequency range. Please provide both a mean and standard deviation value.");
    }
    if (active_buying_min == -1) {active_buying_min = 1;}
    if (active_buying_max == -1) {
      active_buying_max = std::numeric_limits<int>::max();}
 
    active_dist_ = cyclus::NormalIntDist::Ptr (new cyclus::NormalIntDist(active_buying_mean, active_buying_stddev,
                          active_buying_min, active_buying_max));
  }
  else {
    throw cyclus::ValueError("Invalid active buying frequency type");}
 
  if (dormant_buying_frequency_type == "Fixed") {
    dormant_dist_ = cyclus::FixedIntDist::Ptr (new cyclus::FixedIntDist(dormant_buying_val));
  }
  else if (dormant_buying_frequency_type == "Uniform") {
    if ((dormant_buying_min == -1) || (dormant_buying_max == -1)) {
      throw cyclus::ValueError("Invalid dormant buying frequency range. Please provide both a min and max value.");
    }
    dormant_dist_ = cyclus::UniformIntDist::Ptr (new cyclus::UniformIntDist(dormant_buying_min, dormant_buying_max));
  }
  else if (dormant_buying_frequency_type == "Normal") {
    if ((dormant_buying_mean == -1) || (dormant_buying_stddev == -1)) {
      throw cyclus::ValueError("Invalid dormant buying frequency range. Please provide both a mean and standard deviation value.");
    }
    if (dormant_buying_min == -1) {dormant_buying_min = 1;}
    if (dormant_buying_max == -1) {
      dormant_buying_max = std::numeric_limits<int>::max();}
    dormant_dist_ = cyclus::NormalIntDist::Ptr (new cyclus::NormalIntDist(dormant_buying_mean, dormant_buying_stddev,
                          dormant_buying_min, dormant_buying_max));
  }
  else {
    throw cyclus::ValueError("Invalid dormant buying frequency type");}
 
  if (buying_size_type == "Fixed") {
    size_dist_ = cyclus::FixedDoubleDist::Ptr (new cyclus::FixedDoubleDist(buying_size_val));
  }
  else if (buying_size_type == "Uniform") {
    if ((buying_size_min == -1) || (buying_size_max == -1)) {
      throw cyclus::ValueError("Invalid buying size range. Please provide both a min and max value.");
    }
    size_dist_ = cyclus::UniformDoubleDist::Ptr (new cyclus::UniformDoubleDist(buying_size_min, buying_size_max));
  }
  else if (buying_size_type == "Normal") {
    if ((buying_size_mean == -1) || (buying_size_stddev == -1)) {
      throw cyclus::ValueError("Invalid buying size range. Please provide both a mean and standard deviation value.");
    }
    if (buying_size_min == -1) {buying_size_min = 0;}
    if (buying_size_max == -1) {buying_size_max = 1;}
    size_dist_ = cyclus::NormalDoubleDist::Ptr (new cyclus::NormalDoubleDist(buying_size_mean, buying_size_stddev,
                             buying_size_min, buying_size_max));
  }
  else {
    throw cyclus::ValueError("Invalid buying size type");}
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::EnterNotify() {
  cyclus::Facility::EnterNotify();
 
  inventory_tracker.set_capacity(max_inv_size);
  if (reorder_point < 0 && cumulative_cap <= 0) {
    InitBuyPolicyParameters();
    buy_policy.Init(this, &inventory, std::string("inventory"),
                    &inventory_tracker, throughput, active_dist_,
                    dormant_dist_, size_dist_);
  }
  else if (cumulative_cap > 0) {
    InitBuyPolicyParameters();
    buy_policy.Init(this, &inventory, std::string("inventory"),
                    &inventory_tracker, throughput, cumulative_cap,
                    dormant_dist_);
  }
  else if (reorder_quantity > 0) {
    if (reorder_point + reorder_quantity > max_inv_size) {
      throw cyclus::ValueError(
          "reorder_point + reorder_quantity must be less than or equal to max_inv_size");
    }
    buy_policy.Init(this, &inventory, std::string("inventory"),
                    &inventory_tracker, throughput, "RQ",
                    reorder_quantity, reorder_point);
  }
  else {
    buy_policy.Init(this, &inventory, std::string("inventory"),
                    &inventory_tracker, throughput, "sS",
                    max_inv_size, reorder_point);
  }
 
  // dummy comp, use in_recipe if provided
  cyclus::CompMap v;
  cyclus::Composition::Ptr comp = cyclus::Composition::CreateFromAtom(v);
  if (in_recipe != "") {
    comp = context()->GetRecipe(in_recipe);
  }
 
  if (in_commod_prefs.size() == 0) {
    for (int i = 0; i < in_commods.size(); ++i) {
      in_commod_prefs.push_back(cyclus::kDefaultPref);
    }
  } else if (in_commod_prefs.size() != in_commods.size()) {
    std::stringstream ss;
    ss << "in_commod_prefs has " << in_commod_prefs.size()
       << " values, expected " << in_commods.size();
    throw cyclus::ValueError(ss.str());
  }
 
  for (int i = 0; i != in_commods.size(); ++i) {
    buy_policy.Set(in_commods[i], comp, in_commod_prefs[i]);
  }
  buy_policy.Start();
 
  std::string package_name_ =  context()->GetPackage(package)->name();
  std::string tu_name_ = context()->GetTransportUnit(transport_unit)->name();
  if (out_commods.size() == 1) {
    sell_policy.Init(this, &stocks, std::string("stocks"), cyclus::CY_LARGE_DOUBLE, false,
                     sell_quantity, package_name_, tu_name_)
      .Set(out_commods.front())
      .Start();
 
  } else {
    std::stringstream ss;
    ss << "out_commods has " << out_commods.size() << " values, expected 1.";
    throw cyclus::ValueError(ss.str());
  }
  RecordPosition();
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::string Storage::str() {
  std::stringstream ss;
  std::string ans, out_str;
  if (out_commods.size() == 1) {
    out_str = out_commods.front();
  } else {
    out_str = "";
  }
  if (cyclus::toolkit::CommodityProducer::Produces(
          cyclus::toolkit::Commodity(out_str))) {
    ans = "yes";
  } else {
    ans = "no";
  }
  ss << cyclus::Facility::str();
  ss << " has facility parameters {"
     << "\n"
     << "     Output Commodity = " << out_str << ",\n"
     << "     Residence Time = " << residence_time << ",\n"
     << "     Throughput = " << throughput << ",\n"
     << " commod producer members: "
     << " produces " << out_str << "?:" << ans << "'}";
  return ss.str();
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::Tick() {
 
 
  LOG(cyclus::LEV_INFO3, "ComCnv") << prototype() << " is ticking {";
 
  LOG(cyclus::LEV_INFO5, "ComCnv") << "Processing = " << processing.quantity() << ", ready = " << ready.quantity() << ", stocks = " << stocks.quantity() << " and max inventory = " << max_inv_size;
 
  LOG(cyclus::LEV_INFO4, "ComCnv") << "current capacity " << max_inv_size << " - " << processing.quantity() << " - " << ready.quantity() << " - " << stocks.quantity() << " = " << current_capacity();
 
  if (current_capacity() > cyclus::eps_rsrc()) {
    LOG(cyclus::LEV_INFO4, "ComCnv")
        << " has capacity for " << current_capacity() << ".";
  }
  LOG(cyclus::LEV_INFO3, "ComCnv") << "}";
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::Tock() {
  LOG(cyclus::LEV_INFO3, "ComCnv") << prototype() << " is tocking {";
 
  BeginProcessing_();  // place unprocessed inventory into processing
 
  LOG(cyclus::LEV_INFO4, "ComCnv") << "processing currently holds " << processing.quantity() << ". ready currently holds " << ready.quantity() << ".";
 
  if (ready_time() >= 0 || residence_time == 0 && !inventory.empty()) {
    ReadyMatl_(ready_time());  // place processing into ready
  }
 
  LOG(cyclus::LEV_INFO5, "ComCnv") << "Ready now holds " << ready.quantity() << " kg.";
 
  if (ready.quantity() > throughput) {
    LOG(cyclus::LEV_INFO5, "ComCnv") << "Up to " << throughput << " kg will be placed in stocks based on throughput limits. ";
    }
 
  ProcessMat_(throughput);  // place ready into stocks
 
  std::vector<double>::iterator result;
  result = std::max_element(in_commod_prefs.begin(), in_commod_prefs.end());
  int maxindx = std::distance(in_commod_prefs.begin(), result);
  double demand = 0;
  demand = current_capacity();
 
  cyclus::toolkit::RecordTimeSeries<double>("demand"+in_commods[maxindx], this, demand);
 
  // Multiple commodity tracking is not supported, user can only
  // provide one value for out_commods, despite it being a vector of strings.
  cyclus::toolkit::RecordTimeSeries<double>("supply"+out_commods[0], this,
                                            stocks.quantity());
 
  LOG(cyclus::LEV_INFO4, "ComCnv") << "process has "
                                   << processing.quantity() << ". Ready has " << ready.quantity() << ". Stocks has " << stocks.quantity() << ".";
  LOG(cyclus::LEV_INFO3, "ComCnv") << "}";
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::AddMat_(cyclus::Material::Ptr mat) {
  LOG(cyclus::LEV_INFO5, "ComCnv") << prototype() << " is initially holding "
                                   << inventory.quantity() << " total.";
 
  try {
    inventory.Push(mat);
  } catch (cyclus::Error& e) {
    e.msg(Agent::InformErrorMsg(e.msg()));
    throw e;
  }
 
  LOG(cyclus::LEV_INFO5, "ComCnv")
      << prototype() << " added " << mat->quantity()
      << " of material to its inventory, which is holding "
      << inventory.quantity() << " total.";
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::BeginProcessing_() {
  while (inventory.count() > 0) {
    try {
      processing.Push(inventory.Pop());
      entry_times.push_back(context()->time());
 
      LOG(cyclus::LEV_DEBUG2, "ComCnv")
          << "Storage " << prototype()
          << " added resources to processing at t= " << context()->time();
    } catch (cyclus::Error& e) {
      e.msg(Agent::InformErrorMsg(e.msg()));
      throw e;
    }
  }
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::ProcessMat_(double cap) {
  if (!ready.empty()) {
    try {
      double max_pop = std::min(cap, ready.quantity());
 
      if (discrete_handling) {
        if (max_pop == ready.quantity()) {
          stocks.Push(ready.PopN(ready.count()));
        } else {
          double cap_pop = ready.Peek()->quantity();
          while (cap_pop <= max_pop && !ready.empty()) {
            stocks.Push(ready.Pop());
            cap_pop += ready.empty() ? 0 : ready.Peek()->quantity();
          }
        }
      } else {
        stocks.Push(ready.Pop(max_pop, cyclus::eps_rsrc()));
      }
 
      LOG(cyclus::LEV_INFO4, "ComCnv") << "Storage " << prototype()
                                       << " moved resources"
                                       << " from ready to stocks"
                                       << " at t= " << context()->time();
    } catch (cyclus::Error& e) {
      e.msg(Agent::InformErrorMsg(e.msg()));
      throw e;
    }
  }
}
 
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Storage::ReadyMatl_(int time) {
  LOG(cyclus::LEV_INFO5, "ComCnv") << "Placing material into ready";
 
  int to_ready = 0;
 
  while (!entry_times.empty() && entry_times.front() <= time) {
    entry_times.pop_front();
    ++to_ready;
  }
 
  ready.Push(processing.PopN(to_ready));
}
 
void Storage::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* ConstructStorage(cyclus::Context* ctx) {
  return new Storage(ctx);
}
 
}  // namespace cycamore