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"
    "            <a:documentation>recipe accepted by this facility, if unspecified a dummy recipe is used</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"residence_time\">\n"
    "            <a:documentation>the minimum holding time for a received commodity (timesteps).</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"sell_quantity\">\n"
    "            <a:documentation>material will be sold in integer multiples of this quantity. If the buffer contains less than the sell quantity, no material will be offered</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"throughput\">\n"
    "            <a:documentation>the max amount that can be moved through the facility per timestep (kg)</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"max_inv_size\">\n"
    "            <a:documentation>the maximum amount of material that can be in all storage buffer stages</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"discrete_handling\">\n"
    "            <a:documentation>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))</a:documentation>\n"
    "            <data type=\"boolean\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_frequency_type\">\n"
    "            <a:documentation>Options: Fixed, Uniform, Normal, Binomial, FixedWithDisruption. 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. Binomial requires active_buying_end_probability.FixedWithDisruption has a probability that any given cycle will have a disrupted, active length.  Once per cycle, a Bernoulli distribution (Binomial dist with N=1) will be sampled to determine if typical or disrupted cycle. If typical, active_buying_val is cycle length. If disrupted, active_buying_disruption.</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_val\">\n"
    "            <a:documentation>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 dormant)</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_min\">\n"
    "            <a:documentation>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 </a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_max\">\n"
    "            <a:documentation>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 </a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_mean\">\n"
    "            <a:documentation>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 </a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_stddev\">\n"
    "            <a:documentation>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 </a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_end_probability\">\n"
    "            <a:documentation>Binomial distribution has a fixed probability of going dormant at any given timestep, like a weighted coin flip. Required for Binomial active_buying_frequency_type. Must be between 0 and 1</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_disruption_probability\">\n"
    "            <a:documentation>Probability that the agent undergoes a disruption (disrupted active period) during any given cycle. Required for FixedWithDisruption active_buying_frequency_type.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"active_buying_disruption\">\n"
    "            <a:documentation>When a active cycle is disrupted, this is length of the active period instead of active_buying_val. Required for FixedWithDisruption active_buying_frequency_type</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_frequency_type\">\n"
    "            <a:documentation>Options: Fixed, Uniform, Normal, Binomial, FixedWithDisruption. 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. Binomial requires dormant_buying_end_probability. FixedWithDisruption has a probability that any given cycle will have a disrupted, or long, outage.  Once per cycle, a Bernoulli distribution (Binomial dist with N=1) will be sampled to determine if typical or disrupted cycle. If typical, dormant_buying_val is cycle length. If disrupted, dormant_buying_disruption.</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_val\">\n"
    "            <a:documentation>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 active.</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_min\">\n"
    "            <a:documentation>The minimum length in time steps of the dormant buying period. Required for Uniform and optional for Normal dormant_buying_frequency_type.</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_max\">\n"
    "            <a:documentation>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 </a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_mean\">\n"
    "            <a:documentation>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 </a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_stddev\">\n"
    "            <a:documentation>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 </a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_end_probability\">\n"
    "            <a:documentation>Binomial distribution has a fixed probability of going active at any given timestep, like a weighted coin flip. Required for Binomial dormant_buying_frequency_type. Must be between 0 and 1</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_disruption_probability\">\n"
    "            <a:documentation>Probability that the agent undergoes a disruption (longer offline period) during any given cycle. Required for FixedWithDisruption dormant_buying_frequency_type.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"dormant_buying_disruption\">\n"
    "            <a:documentation>When a dormant cycle is disrupted, this is length of the offline period instead of dormant_buying_val. Required for FixedWithDisruption dormant_buying_frequency_type</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_type\">\n"
    "            <a:documentation>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.</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_val\">\n"
    "            <a:documentation>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</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_min\">\n"
    "            <a:documentation>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.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_max\">\n"
    "            <a:documentation>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 </a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_mean\">\n"
    "            <a:documentation>The mean size of the buy request as a fraction of maximum capacity. Required for Normal buying_size_type.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"buying_size_stddev\">\n"
    "            <a:documentation>The standard deviation of the size of the buy request as a fraction of maximum capacity. Required for Normal buying_size_type.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"reorder_point\">\n"
    "            <a:documentation>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.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"reorder_quantity\">\n"
    "            <a:documentation>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.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"cumulative_cap\">\n"
    "            <a:documentation>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.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"package\">\n"
    "            <a:documentation>Outgoing material will be packaged when trading.</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"transport_unit\">\n"
    "            <a:documentation>Outgoing material, after packaging, will be further restricted by transport unit when trading.</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"latitude\">\n"
    "            <a:documentation>Latitude of the agent's geographical position. The value should be expressed in degrees as a double.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"longitude\">\n"
    "            <a:documentation>Longitude of the agent's geographical position. The value should be expressed in degrees as a double.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "</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\":[\"EconomicEntity\",\"cyclus::Agent\",\"cyclus:"
    ":Facility\",\"cyclus::Ider\",\"cyclus::StateWrangler\","
    "\"cyclus::TimeListener\",\"cyclus::Trader\",\"cyclus::t"
    "oolkit::AgentManaged\",\"cyclus::toolkit::CommodityP"
    "roducer\",\"cyclus::toolkit::Position\"],\"vars\":{\"in_"
    "commods\":{\"tooltip\":[\"input "
    "commodity\",\"\"],\"doc\":\"commodities accepted by this"
    " facility\",\"uilabel\":[\"Input Commodities\",\"\"],\"uit"
    "ype\":[\"oneormore\",\"incommodity\"],\"type\":[\"std::vec"
    "tor\",\"std::string\"],\"index\":0,\"shape\":[-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, Binomial, FixedWithDisruption. "
    "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. Binomial requires "
    "active_buying_end_probability.FixedWithDisruption "
    "has a probability that any given cycle will have a"
    " disrupted, active length.  Once per cycle, a "
    "Bernoulli distribution (Binomial dist with N=1) "
    "will be sampled to determine if typical or "
    "disrupted cycle. If typical, active_buying_val is "
    "cycle length. If disrupted, active_buying_disrupti"
    "on.\",\"uitype\":\"combobox\",\"categorical\":[\"Fixed\",\"U"
    "niform\",\"Normal\",\"Binomial\",\"FixedWithDisruption\"]"
    ",\"uilabel\":\"Active Buying Frequency Type\",\"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\"},\"active_buying_"
    "end_probability\":{\"default\":0,\"tooltip\":\"Probabili"
    "ty that agent will go offline during the next time"
    " step\",\"doc\":\"Binomial distribution has a fixed "
    "probability of going dormant at any given "
    "timestep, like a weighted coin flip. Required for "
    "Binomial active_buying_frequency_type. Must be "
    "between 0 and 1\",\"uitype\":\"range\",\"range\":[0.0,1.0"
    "],\"uilabel\":\"Active Buying Offline Probability\",\"t"
    "ype\":\"double\",\"index\":15,\"shape\":[-"
    "1],\"alias\":\"active_buying_end_probability\"},\"activ"
    "e_buying_disruption_probability\":{\"default\":0,\"too"
    "ltip\":\"Probability that a cycle contains a "
    "disruption\",\"doc\":\"Probability that the agent "
    "undergoes a disruption (disrupted active period) "
    "during any given cycle. Required for "
    "FixedWithDisruption active_buying_frequency_type.\""
    ",\"uitype\":\"range\",\"range\":[0.0,1.0],\"uilabel\":\"Act"
    "ive Buying Disruption Probability\",\"type\":\"double\""
    ",\"index\":16,\"shape\":[-"
    "1],\"alias\":\"active_buying_disruption_probability\"}"
    ",\"active_buying_disruption\":{\"default\":-"
    "1,\"tooltip\":\"Fixed length of disrupted active "
    "cycle\",\"doc\":\"When a active cycle is disrupted, "
    "this is length of the active period instead of "
    "active_buying_val. Required for "
    "FixedWithDisruption active_buying_frequency_type\","
    "\"uitype\":\"range\",\"range\":[0,2147483647],\"type\":\"in"
    "t\",\"index\":17,\"shape\":[-"
    "1],\"alias\":\"active_buying_disruption\",\"uilabel\":\"a"
    "ctive_buying_disruption\"},\"dormant_buying_frequenc"
    "y_type\":{\"default\":\"Fixed\",\"tooltip\":\"Type of "
    "dormant buying frequency\",\"doc\":\"Options: Fixed, "
    "Uniform, Normal, Binomial, FixedWithDisruption. "
    "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. Binomial requires "
    "dormant_buying_end_probability. "
    "FixedWithDisruption has a probability that any "
    "given cycle will have a disrupted, or long, "
    "outage.  Once per cycle, a Bernoulli distribution "
    "(Binomial dist with N=1) will be sampled to "
    "determine if typical or disrupted cycle. If "
    "typical, dormant_buying_val is cycle length. If "
    "disrupted, dormant_buying_disruption.\",\"uitype\":\"c"
    "ombobox\",\"categorical\":[\"Fixed\",\"Uniform\",\"Normal\""
    ",\"Binomial\",\"FixedWithDisruption\"],\"uilabel\":\"Dorm"
    "ant Buying Frequency Type\",\"type\":\"std::string\",\"i"
    "ndex\":18,\"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\":19,\"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\":20,\"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\":21,\"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\":22,\"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\":23,\"sh"
    "ape\":[-"
    "1],\"alias\":\"dormant_buying_stddev\"},\"dormant_buyin"
    "g_end_probability\":{\"default\":0,\"tooltip\":\"Probabi"
    "lity that agent will return to active during the "
    "next time step\",\"doc\":\"Binomial distribution has a"
    " fixed probability of going active at any given "
    "timestep, like a weighted coin flip. Required for "
    "Binomial dormant_buying_frequency_type. Must be "
    "between 0 and 1\",\"uitype\":\"range\",\"range\":[0.0,1.0"
    "],\"uilabel\":\"Dormant Buying Binomial Offline Proba"
    "bility\",\"type\":\"double\",\"index\":24,\"shape\":[-"
    "1],\"alias\":\"dormant_buying_end_probability\"},\"dorm"
    "ant_buying_disruption_probability\":{\"default\":0,\"t"
    "ooltip\":\"Probability that a cycle contains a "
    "disruption\",\"doc\":\"Probability that the agent "
    "undergoes a disruption (longer offline period) "
    "during any given cycle. Required for "
    "FixedWithDisruption dormant_buying_frequency_type."
    "\",\"uitype\":\"range\",\"range\":[0.0,1.0],\"uilabel\":\"Do"
    "rmant Buying Disruption Probability\",\"type\":\"doubl"
    "e\",\"index\":25,\"shape\":[-"
    "1],\"alias\":\"dormant_buying_disruption_probability\""
    "},\"dormant_buying_disruption\":{\"default\":-"
    "1,\"tooltip\":\"Fixed length of disrupted "
    "cycle\",\"doc\":\"When a dormant cycle is disrupted, "
    "this is length of the offline period instead of "
    "dormant_buying_val. Required for "
    "FixedWithDisruption dormant_buying_frequency_type\""
    ",\"uitype\":\"range\",\"range\":[0,2147483647],\"type\":\"i"
    "nt\",\"index\":26,\"shape\":[-"
    "1],\"alias\":\"dormant_buying_disruption\",\"uilabel\":\""
    "dormant_buying_disruption\"},\"buying_size_type\":{\"d"
    "efault\":\"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 b"
    "uying_size_max.\",\"uitype\":\"combobox\",\"categorical\""
    ":[\"Fixed\",\"Uniform\",\"Normal\"],\"uilabel\":\"Buying "
    "Size Type\",\"type\":\"std::string\",\"index\":27,\"shape\""
    ":[-"
    "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\":28,\"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"
    "9,\"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\":30,\"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\":31,\"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\":32,\"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\":33,\"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\":34,\"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\":35,\"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\":36,\"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\":37,\"shape"
    "\":[-"
    "1],\"alias\":\"transport_unit\"},\"inventory\":{\"tooltip"
    "\":\"Incoming material buffer\",\"type\":[\"cyclus::tool"
    "kit::ResBuf\",\"cyclus::Material\"],\"index\":38,\"shape"
    "\":[-1,-1]},\"stocks\":{\"tooltip\":\"Output material bu"
    "ffer\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::M"
    "aterial\"],\"index\":39,\"shape\":[-1,-"
    "1]},\"ready\":{\"tooltip\":\"Buffer for material held "
    "for required residence_time\",\"type\":[\"cyclus::tool"
    "kit::ResBuf\",\"cyclus::Material\"],\"index\":40,\"shape"
    "\":[-1,-1]},\"processing\":{\"tooltip\":\"Buffer for "
    "material still waiting for required residence_time"
    "\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::Mater"
    "ial\"],\"index\":41,\"shape\":[-1,-"
    "1]},\"inventory_tracker\":{\"tooltip\":\"Total "
    "Inventory Tracker to restrict maximum agent invent"
    "ory\",\"type\":\"cyclus::toolkit::TotalInvTracker\",\"in"
    "dex\":42,\"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\":43,\"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\":44,\"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_active_buying_end_probability[1] = {-1};
  cycpp_shape_active_buying_end_probability = std::vector<int>(rawcycpp_shape_active_buying_end_probability, rawcycpp_shape_active_buying_end_probability + 1);
  int rawcycpp_shape_active_buying_disruption_probability[1] = {-1};
  cycpp_shape_active_buying_disruption_probability = std::vector<int>(rawcycpp_shape_active_buying_disruption_probability, rawcycpp_shape_active_buying_disruption_probability + 1);
  int rawcycpp_shape_active_buying_disruption[1] = {-1};
  cycpp_shape_active_buying_disruption = std::vector<int>(rawcycpp_shape_active_buying_disruption, rawcycpp_shape_active_buying_disruption + 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_dormant_buying_end_probability[1] = {-1};
  cycpp_shape_dormant_buying_end_probability = std::vector<int>(rawcycpp_shape_dormant_buying_end_probability, rawcycpp_shape_dormant_buying_end_probability + 1);
  int rawcycpp_shape_dormant_buying_disruption_probability[1] = {-1};
  cycpp_shape_dormant_buying_disruption_probability = std::vector<int>(rawcycpp_shape_dormant_buying_disruption_probability, rawcycpp_shape_dormant_buying_disruption_probability + 1);
  int rawcycpp_shape_dormant_buying_disruption[1] = {-1};
  cycpp_shape_dormant_buying_disruption = std::vector<int>(rawcycpp_shape_dormant_buying_disruption, rawcycpp_shape_dormant_buying_disruption + 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("active_buying_end_probability") > 0) {
    {
      double active_buying_end_probability_val = cyclus::Query<double>(sub, "active_buying_end_probability");
      active_buying_end_probability = active_buying_end_probability_val;
    }
  } else {
    double active_buying_end_probability_tmp = 0;
    active_buying_end_probability = active_buying_end_probability_tmp;
  }
  if (sub->NMatches("active_buying_disruption_probability") > 0) {
    {
      double active_buying_disruption_probability_val = cyclus::Query<double>(sub, "active_buying_disruption_probability");
      active_buying_disruption_probability = active_buying_disruption_probability_val;
    }
  } else {
    double active_buying_disruption_probability_tmp = 0;
    active_buying_disruption_probability = active_buying_disruption_probability_tmp;
  }
  if (sub->NMatches("active_buying_disruption") > 0) {
    {
      int active_buying_disruption_val = cyclus::Query<int>(sub, "active_buying_disruption");
      active_buying_disruption = active_buying_disruption_val;
    }
  } else {
    int active_buying_disruption_tmp = -1;
    active_buying_disruption = active_buying_disruption_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("dormant_buying_end_probability") > 0) {
    {
      double dormant_buying_end_probability_val = cyclus::Query<double>(sub, "dormant_buying_end_probability");
      dormant_buying_end_probability = dormant_buying_end_probability_val;
    }
  } else {
    double dormant_buying_end_probability_tmp = 0;
    dormant_buying_end_probability = dormant_buying_end_probability_tmp;
  }
  if (sub->NMatches("dormant_buying_disruption_probability") > 0) {
    {
      double dormant_buying_disruption_probability_val = cyclus::Query<double>(sub, "dormant_buying_disruption_probability");
      dormant_buying_disruption_probability = dormant_buying_disruption_probability_val;
    }
  } else {
    double dormant_buying_disruption_probability_tmp = 0;
    dormant_buying_disruption_probability = dormant_buying_disruption_probability_tmp;
  }
  if (sub->NMatches("dormant_buying_disruption") > 0) {
    {
      int dormant_buying_disruption_val = cyclus::Query<int>(sub, "dormant_buying_disruption");
      dormant_buying_disruption = dormant_buying_disruption_val;
    }
  } else {
    int dormant_buying_disruption_tmp = -1;
    dormant_buying_disruption = dormant_buying_disruption_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("active_buying_end_probability", active_buying_end_probability, &cycpp_shape_active_buying_end_probability)
  ->AddVal("active_buying_disruption_probability", active_buying_disruption_probability, &cycpp_shape_active_buying_disruption_probability)
  ->AddVal("active_buying_disruption", active_buying_disruption, &cycpp_shape_active_buying_disruption)
  ->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("dormant_buying_end_probability", dormant_buying_end_probability, &cycpp_shape_dormant_buying_end_probability)
  ->AddVal("dormant_buying_disruption_probability", dormant_buying_disruption_probability, &cycpp_shape_dormant_buying_disruption_probability)
  ->AddVal("dormant_buying_disruption", dormant_buying_disruption, &cycpp_shape_dormant_buying_disruption)
  ->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("active_buying_end_probability", active_buying_end_probability, &cycpp_shape_active_buying_end_probability)
  ->AddVal("active_buying_disruption_probability", active_buying_disruption_probability, &cycpp_shape_active_buying_disruption_probability)
  ->AddVal("active_buying_disruption", active_buying_disruption, &cycpp_shape_active_buying_disruption)
  ->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("dormant_buying_end_probability", dormant_buying_end_probability, &cycpp_shape_dormant_buying_end_probability)
  ->AddVal("dormant_buying_disruption_probability", dormant_buying_disruption_probability, &cycpp_shape_dormant_buying_disruption_probability)
  ->AddVal("dormant_buying_disruption", dormant_buying_disruption, &cycpp_shape_dormant_buying_disruption)
  ->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_active_buying_end_probability[1] = {-1};
    cycpp_shape_active_buying_end_probability = std::vector<int>(rawcycpp_shape_active_buying_end_probability, rawcycpp_shape_active_buying_end_probability + 1);
    int rawcycpp_shape_active_buying_disruption_probability[1] = {-1};
    cycpp_shape_active_buying_disruption_probability = std::vector<int>(rawcycpp_shape_active_buying_disruption_probability, rawcycpp_shape_active_buying_disruption_probability + 1);
    int rawcycpp_shape_active_buying_disruption[1] = {-1};
    cycpp_shape_active_buying_disruption = std::vector<int>(rawcycpp_shape_active_buying_disruption, rawcycpp_shape_active_buying_disruption + 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_dormant_buying_end_probability[1] = {-1};
    cycpp_shape_dormant_buying_end_probability = std::vector<int>(rawcycpp_shape_dormant_buying_end_probability, rawcycpp_shape_dormant_buying_end_probability + 1);
    int rawcycpp_shape_dormant_buying_disruption_probability[1] = {-1};
    cycpp_shape_dormant_buying_disruption_probability = std::vector<int>(rawcycpp_shape_dormant_buying_disruption_probability, rawcycpp_shape_dormant_buying_disruption_probability + 1);
    int rawcycpp_shape_dormant_buying_disruption[1] = {-1};
    cycpp_shape_dormant_buying_disruption = std::vector<int>(rawcycpp_shape_dormant_buying_disruption, rawcycpp_shape_dormant_buying_disruption + 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;
    active_buying_end_probability = m->active_buying_end_probability;
    active_buying_disruption_probability = m->active_buying_disruption_probability;
    active_buying_disruption = m->active_buying_disruption;
    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;
    dormant_buying_end_probability = m->dormant_buying_end_probability;
    dormant_buying_disruption_probability = m->dormant_buying_disruption_probability;
    dormant_buying_disruption = m->dormant_buying_disruption;
    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_active_buying_end_probability[1] = {-1};
    cycpp_shape_active_buying_end_probability = std::vector<int>(rawcycpp_shape_active_buying_end_probability, rawcycpp_shape_active_buying_end_probability + 1);
    int rawcycpp_shape_active_buying_disruption_probability[1] = {-1};
    cycpp_shape_active_buying_disruption_probability = std::vector<int>(rawcycpp_shape_active_buying_disruption_probability, rawcycpp_shape_active_buying_disruption_probability + 1);
    int rawcycpp_shape_active_buying_disruption[1] = {-1};
    cycpp_shape_active_buying_disruption = std::vector<int>(rawcycpp_shape_active_buying_disruption, rawcycpp_shape_active_buying_disruption + 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_dormant_buying_end_probability[1] = {-1};
    cycpp_shape_dormant_buying_end_probability = std::vector<int>(rawcycpp_shape_dormant_buying_end_probability, rawcycpp_shape_dormant_buying_end_probability + 1);
    int rawcycpp_shape_dormant_buying_disruption_probability[1] = {-1};
    cycpp_shape_dormant_buying_disruption_probability = std::vector<int>(rawcycpp_shape_dormant_buying_disruption_probability, rawcycpp_shape_dormant_buying_disruption_probability + 1);
    int rawcycpp_shape_dormant_buying_disruption[1] = {-1};
    cycpp_shape_dormant_buying_disruption = std::vector<int>(rawcycpp_shape_dormant_buying_disruption, rawcycpp_shape_dormant_buying_disruption + 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");
    active_buying_end_probability = qr.GetVal<double>("active_buying_end_probability");
    active_buying_disruption_probability = qr.GetVal<double>("active_buying_disruption_probability");
    active_buying_disruption = qr.GetVal<int>("active_buying_disruption");
    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");
    dormant_buying_end_probability = qr.GetVal<double>("dormant_buying_end_probability");
    dormant_buying_disruption_probability = qr.GetVal<double>("dormant_buying_disruption_probability");
    dormant_buying_disruption = qr.GetVal<int>("dormant_buying_disruption");
    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 if (active_buying_frequency_type == "Binomial") {
    if (active_buying_end_probability < 0 || active_buying_end_probability > 1) {
      throw cyclus::ValueError("Active buying end probability must be between 0 and 1");
    }
    int success = 1; // only one success is needed to end the active buying period
    active_dist_ = cyclus::NegativeBinomialIntDist::Ptr (new cyclus::NegativeBinomialIntDist(success, active_buying_end_probability));
  } else if (active_buying_frequency_type == "FixedWithDisruption") {
    if (active_buying_disruption < 0) {
      throw cyclus::ValueError("Disruption must be greater than or equal to 0");
    }
    active_dist_ = cyclus::BinaryIntDist::Ptr (
      new cyclus::BinaryIntDist(active_buying_disruption_probability,
      active_buying_disruption, active_buying_val));
  }
  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 if (dormant_buying_frequency_type == "Binomial") {
    if (dormant_buying_end_probability < 0 || dormant_buying_end_probability > 1) {
      throw cyclus::ValueError("Dormant buying end probability must be between 0 and 1");
    }
    int success = 1; // only one success is needed to end the dormant buying period
    dormant_dist_ = cyclus::NegativeBinomialIntDist::Ptr (new cyclus::NegativeBinomialIntDist(success, dormant_buying_end_probability));
  } else if (dormant_buying_frequency_type == "FixedWithDisruption") {
    if (dormant_buying_disruption < 0) {
      throw cyclus::ValueError("Disruption must be greater than or equal to 0");
    }
    dormant_dist_ = cyclus::BinaryIntDist::Ptr (
      new cyclus::BinaryIntDist(dormant_buying_disruption_probability,
      dormant_buying_disruption, dormant_buying_val));
  }
  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