build/cycamore/sink.cc

Go to the documentation of this file.

#line 1 "/cycamore/src/sink.cc"
// Implements the Sink class
#include <algorithm>
#include <sstream>
 
#include <boost/lexical_cast.hpp>
 
#include "sink.h"
 
namespace cycamore {
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Sink::Sink(cyclus::Context* ctx)
    : cyclus::Facility(ctx),
      capacity(std::numeric_limits<double>::max()),
      keep_packaging(true) {
  SetMaxInventorySize(std::numeric_limits<double>::max());}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Sink::~Sink() {}
std::string Sink::schema() {
  return ""
    "<interleave>\n"
    "    <optional>\n"
    "        <element name=\"latitude\">\n"
    "            <a:documentation>Latitude of the agent's geographical position. The value should be expressed in degrees as a double.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"longitude\">\n"
    "            <a:documentation>Longitude of the agent's geographical position. The value should be expressed in degrees as a double.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <element name=\"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"
    "    <optional>\n"
    "        <element name=\"recipe_name\">\n"
    "            <a:documentation>name of recipe to use for material requests, where the default (empty string) is to accept everything</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"max_inv_size\">\n"
    "            <a:documentation>total maximum inventory size of sink facility</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"capacity\">\n"
    "            <a:documentation>capacity the sink facility can accept at each time step</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_size_type\">\n"
    "            <a:documentation>type of random behavior to use. Default None, other options are 'UniformReal', 'UniformInt', 'NormalReal', and 'NormalInt'</a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_size_mean\">\n"
    "            <a:documentation>When a normal distribution is used to determine the size of the request, this is the fraction of available space to use as the mean. Default 1.0. Note that values significantly above 1 without a correspondingly large std dev may result in inefficient use of the random number generator.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_size_stddev\">\n"
    "            <a:documentation>When a normal distribution is used to determine the size of the request, this is the fraction of available space to use as the standard deviation. Default 0.1</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_type\">\n"
    "            <a:documentation>type of random behavior to use. Default None, other options are, 'UniformInt', and 'NormalInt'. When using 'UniformInt', also set 'random_frequency_min' and 'random_frequency_max'. For 'NormalInt', set 'random_frequency_mean' and 'random_fequency_stddev', min and max values are optional. </a:documentation>\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_mean\">\n"
    "            <a:documentation>When a normal distribution is used to determine the frequency of the request, this is the mean. Default 1</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_stddev\">\n"
    "            <a:documentation>When a normal distribution is used to determine the frequency of the request, this is the standard deviation. Default 1</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_min\">\n"
    "            <a:documentation>When a random distribution is used to determine the frequency of the request, this is the lower bound. Default 1</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_max\">\n"
    "            <a:documentation>When a random distribution is used to determine the frequency of the request, this is the upper bound. Default 2147483647 (CY_LARGE_INT)</a:documentation>\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"keep_packaging\">\n"
    "            <a:documentation>Boolean value about whether to keep packaging. If true, packaging will not be stripped upon acceptance into the sink. If false, package type will be stripped immediately upon acceptance. Has no effect if the incoming material is not packaged.</a:documentation>\n"
    "            <data type=\"boolean\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "</interleave>\n";
};
#line 20 "/cycamore/src/sink.cc"
 
Json::Value Sink::annotations() {
  Json::Value root;
  Json::Reader reader;
  bool parsed_ok = reader.parse(
    "{\"name\":\"cycamore::Sink\",\"entity\":\"facility\",\"pare"
    "nts\":[\"cyclus::Facility\",\"cyclus::toolkit::Positio"
    "n\"],\"all_parents\":[\"EconomicEntity\",\"cyclus::Agent"
    "\",\"cyclus::Facility\",\"cyclus::Ider\",\"cyclus::State"
    "Wrangler\",\"cyclus::TimeListener\",\"cyclus::Trader\","
    "\"cyclus::toolkit::Position\"],\"vars\":{\"latitude\":{\""
    "default\":0.0,\"uilabel\":\"Geographical latitude in "
    "degrees as a double\",\"doc\":\"Latitude of the "
    "agent's geographical position. The value should be"
    " expressed in degrees as a double.\",\"type\":\"double"
    "\",\"index\":0,\"shape\":[-"
    "1],\"alias\":\"latitude\",\"tooltip\":\"latitude\"},\"longi"
    "tude\":{\"default\":0.0,\"uilabel\":\"Geographical "
    "longitude in degrees as a double\",\"doc\":\"Longitude"
    " of the agent's geographical position. The value "
    "should be expressed in degrees as a double.\",\"type"
    "\":\"double\",\"index\":1,\"shape\":[-"
    "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"},\"in_"
    "commods\":{\"tooltip\":[\"input "
    "commodities\",\"\"],\"doc\":\"commodities that the sink "
    "facility accepts\",\"uilabel\":[\"List of Input Commod"
    "ities\",\"\"],\"uitype\":[\"oneormore\",\"incommodity\"],\"t"
    "ype\":[\"std::vector\",\"std::string\"],\"index\":2,\"shap"
    "e\":[-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\":3,\"shape\":[-1,-"
    "1],\"alias\":[\"in_commod_prefs\",\"val\"],\"tooltip\":[\"i"
    "n_commod_prefs\",\"\"]},\"recipe_name\":{\"default\":\"\",\""
    "tooltip\":\"requested composition\",\"doc\":\"name of "
    "recipe to use for material requests, where the "
    "default (empty string) is to accept "
    "everything\",\"uilabel\":\"Input Recipe\",\"uitype\":\"inr"
    "ecipe\",\"type\":\"std::string\",\"index\":4,\"shape\":[-"
    "1],\"alias\":\"recipe_name\"},\"max_inv_size\":{\"default"
    "\":1e+299,\"tooltip\":\"sink maximum inventory "
    "size\",\"uilabel\":\"Maximum Inventory\",\"uitype\":\"rang"
    "e\",\"range\":[0.0,1e+299],\"doc\":\"total maximum "
    "inventory size of sink facility\",\"type\":\"double\",\""
    "index\":5,\"shape\":[-"
    "1],\"alias\":\"max_inv_size\"},\"capacity\":{\"default\":1"
    "e+299,\"tooltip\":\"sink capacity\",\"uilabel\":\"Maximum"
    " Throughput\",\"uitype\":\"range\",\"range\":[0.0,1e+299]"
    ",\"doc\":\"capacity the sink facility can accept at "
    "each time step\",\"type\":\"double\",\"index\":6,\"shape\":"
    "[-"
    "1],\"alias\":\"capacity\"},\"inventory\":{\"capacity\":\"ma"
    "x_inv_size\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyc"
    "lus::Resource\"],\"index\":7,\"shape\":[-1,-"
    "1]},\"random_size_type\":{\"default\":\"None\",\"tooltip\""
    ":\"type of random behavior when setting the size of"
    " the "
    "request\",\"uitype\":\"combobox\",\"uilabel\":\"Random Siz"
    "e\",\"categorical\":[\"None\",\"UniformReal\",\"UniformInt"
    "\",\"NormalReal\",\"NormalInt\"],\"doc\":\"type of random "
    "behavior to use. Default None, other options are "
    "'UniformReal', 'UniformInt', 'NormalReal', and 'No"
    "rmalInt'\",\"type\":\"std::string\",\"index\":8,\"shape\":["
    "-1],\"alias\":\"random_size_type\"},\"random_size_mean\""
    ":{\"default\":1.0,\"tooltip\":\"fraction of available "
    "space to determine the mean\",\"uilabel\":\"Random "
    "Size Mean\",\"uitype\":\"range\",\"range\":[0.0,1e+299],\""
    "doc\":\"When a normal distribution is used to "
    "determine the size of the request, this is the "
    "fraction of available space to use as the mean. "
    "Default 1.0. Note that values significantly above "
    "1 without a correspondingly large std dev may "
    "result in inefficient use of the random number gen"
    "erator.\",\"type\":\"double\",\"index\":9,\"shape\":[-"
    "1],\"alias\":\"random_size_mean\"},\"random_size_stddev"
    "\":{\"default\":0.1,\"tooltip\":\"fraction of available "
    "space to determine the std dev\",\"uilabel\":\"Random "
    "Size Std Dev\",\"uitype\":\"range\",\"range\":[0.0,1e+299"
    "],\"doc\":\"When a normal distribution is used to "
    "determine the size of the request, this is the "
    "fraction of available space to use as the standard"
    " deviation. Default 0.1\",\"type\":\"double\",\"index\":1"
    "0,\"shape\":[-"
    "1],\"alias\":\"random_size_stddev\"},\"random_frequency"
    "_type\":{\"default\":\"None\",\"tooltip\":\"type of random"
    " behavior when setting the timing of the "
    "request\",\"uitype\":\"combobox\",\"uilabel\":\"Random Tim"
    "ing\",\"categorical\":[\"None\",\"UniformInt\",\"NormalInt"
    "\"],\"doc\":\"type of random behavior to use. Default "
    "None, other options are, 'UniformInt', and "
    "'NormalInt'. When using 'UniformInt', also set "
    "'random_frequency_min' and 'random_frequency_max'."
    " For 'NormalInt', set 'random_frequency_mean' and "
    "'random_fequency_stddev', min and max values are "
    "optional. \",\"type\":\"std::string\",\"index\":11,\"shape"
    "\":[-"
    "1],\"alias\":\"random_frequency_type\"},\"random_freque"
    "ncy_mean\":{\"default\":1,\"tooltip\":\"mean of the "
    "random frequency\",\"uilabel\":\"Random Frequency Mean"
    "\",\"uitype\":\"range\",\"range\":[0.0,1e+299],\"doc\":\"Whe"
    "n a normal distribution is used to determine the "
    "frequency of the request, this is the mean. "
    "Default 1\",\"type\":\"double\",\"index\":12,\"shape\":[-"
    "1],\"alias\":\"random_frequency_mean\"},\"random_freque"
    "ncy_stddev\":{\"default\":1,\"tooltip\":\"std dev of the"
    " random frequency\",\"uilabel\":\"Random Frequency Std"
    " Dev\",\"uitype\":\"range\",\"range\":[0.0,1e+299],\"doc\":"
    "\"When a normal distribution is used to determine "
    "the frequency of the request, this is the standard"
    " deviation. Default 1\",\"type\":\"double\",\"index\":13,"
    "\"shape\":[-"
    "1],\"alias\":\"random_frequency_stddev\"},\"random_freq"
    "uency_min\":{\"default\":1,\"tooltip\":\"lower bound of "
    "the random frequency\",\"uilabel\":\"Random Frequency "
    "Lower Bound\",\"uitype\":\"range\",\"range\":[1,214748364"
    "7],\"doc\":\"When a random distribution is used to "
    "determine the frequency of the request, this is "
    "the lower bound. Default 1\",\"type\":\"int\",\"index\":1"
    "4,\"shape\":[-"
    "1],\"alias\":\"random_frequency_min\"},\"random_frequen"
    "cy_max\":{\"default\":2147483647,\"tooltip\":\"upper "
    "bound of the random frequency\",\"uilabel\":\"Random "
    "Frequency Upper Bound\",\"uitype\":\"range\",\"range\":[1"
    ",2147483647],\"doc\":\"When a random distribution is "
    "used to determine the frequency of the request, "
    "this is the upper bound. Default 2147483647 (CY_LA"
    "RGE_INT)\",\"type\":\"int\",\"index\":15,\"shape\":[-"
    "1],\"alias\":\"random_frequency_max\"},\"keep_packaging"
    "\":{\"default\":true,\"tooltip\":\"Whether to persist "
    "packaging in the sink.\",\"doc\":\"Boolean value about"
    " whether to keep packaging. If true, packaging "
    "will not be stripped upon acceptance into the "
    "sink. If false, package type will be stripped "
    "immediately upon acceptance. Has no effect if the "
    "incoming material is not "
    "packaged.\",\"uilabel\":\"Keep Packaging\",\"uitype\":\"bo"
    "ol\",\"type\":\"bool\",\"index\":16,\"shape\":[-"
    "1],\"alias\":\"keep_packaging\"}},\"doc\":\" A sink "
    "facility that accepts materials and products with "
    "a fixed\\n throughput (per time step) capacity and "
    "a lifetime capacity defined by\\n a total inventory"
    " size. The inventory size and throughput "
    "capacity\\n both default to infinite. If a recipe "
    "is provided, it will request\\n material with that "
    "recipe. Requests are made for any number of\\n "
    "specified commodities.\\n\"}", root);
  if (!parsed_ok) {
    throw cyclus::ValueError("failed to parse annotations for cycamore::Sink.");
  }
  return root;
};
#line 22 "/cycamore/src/sink.cc"
 
void Sink::InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
  cyclus::Facility::InfileToDb(tree, di);
  int rawcycpp_shape_latitude[1] = {-1};
  cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
  int rawcycpp_shape_longitude[1] = {-1};
  cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
  int rawcycpp_shape_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_recipe_name[1] = {-1};
  cycpp_shape_recipe_name = std::vector<int>(rawcycpp_shape_recipe_name, rawcycpp_shape_recipe_name + 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_capacity[1] = {-1};
  cycpp_shape_capacity = std::vector<int>(rawcycpp_shape_capacity, rawcycpp_shape_capacity + 1);
  int rawcycpp_shape_inventory[2] = {-1, -1};
  cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
  int rawcycpp_shape_random_size_type[1] = {-1};
  cycpp_shape_random_size_type = std::vector<int>(rawcycpp_shape_random_size_type, rawcycpp_shape_random_size_type + 1);
  int rawcycpp_shape_random_size_mean[1] = {-1};
  cycpp_shape_random_size_mean = std::vector<int>(rawcycpp_shape_random_size_mean, rawcycpp_shape_random_size_mean + 1);
  int rawcycpp_shape_random_size_stddev[1] = {-1};
  cycpp_shape_random_size_stddev = std::vector<int>(rawcycpp_shape_random_size_stddev, rawcycpp_shape_random_size_stddev + 1);
  int rawcycpp_shape_random_frequency_type[1] = {-1};
  cycpp_shape_random_frequency_type = std::vector<int>(rawcycpp_shape_random_frequency_type, rawcycpp_shape_random_frequency_type + 1);
  int rawcycpp_shape_random_frequency_mean[1] = {-1};
  cycpp_shape_random_frequency_mean = std::vector<int>(rawcycpp_shape_random_frequency_mean, rawcycpp_shape_random_frequency_mean + 1);
  int rawcycpp_shape_random_frequency_stddev[1] = {-1};
  cycpp_shape_random_frequency_stddev = std::vector<int>(rawcycpp_shape_random_frequency_stddev, rawcycpp_shape_random_frequency_stddev + 1);
  int rawcycpp_shape_random_frequency_min[1] = {-1};
  cycpp_shape_random_frequency_min = std::vector<int>(rawcycpp_shape_random_frequency_min, rawcycpp_shape_random_frequency_min + 1);
  int rawcycpp_shape_random_frequency_max[1] = {-1};
  cycpp_shape_random_frequency_max = std::vector<int>(rawcycpp_shape_random_frequency_max, rawcycpp_shape_random_frequency_max + 1);
  int rawcycpp_shape_keep_packaging[1] = {-1};
  cycpp_shape_keep_packaging = std::vector<int>(rawcycpp_shape_keep_packaging, rawcycpp_shape_keep_packaging + 1);
  cyclus::InfileTree* sub = tree->SubTree("config/*");
  int i;
  int n;
  if (sub->NMatches("latitude") > 0) {
    {
      double latitude_val = cyclus::Query<double>(sub, "latitude");
      latitude = latitude_val;
    }
  } else {
    double latitude_tmp = 0.0;
    latitude = latitude_tmp;
  }
  if (sub->NMatches("longitude") > 0) {
    {
      double longitude_val = cyclus::Query<double>(sub, "longitude");
      longitude = longitude_val;
    }
  } else {
    double longitude_tmp = 0.0;
    longitude = longitude_tmp;
  }
  {
    cyclus::InfileTree* bub = sub->SubTree("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;
  }
  if (sub->NMatches("recipe_name") > 0) {
    {
      std::string recipe_name_val = cyclus::Query<std::string>(sub, "recipe_name");
      recipe_name = recipe_name_val;
    }
  } else {
    std::string recipe_name_tmp("");
    recipe_name = recipe_name_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("capacity") > 0) {
    {
      double capacity_val = cyclus::Query<double>(sub, "capacity");
      capacity = capacity_val;
    }
  } else {
    double capacity_tmp = 1e+299;
    capacity = capacity_tmp;
  }
  if (sub->NMatches("random_size_type") > 0) {
    {
      std::string random_size_type_val = cyclus::Query<std::string>(sub, "random_size_type");
      random_size_type = random_size_type_val;
    }
  } else {
    std::string random_size_type_tmp("None");
    random_size_type = random_size_type_tmp;
  }
  if (sub->NMatches("random_size_mean") > 0) {
    {
      double random_size_mean_val = cyclus::Query<double>(sub, "random_size_mean");
      random_size_mean = random_size_mean_val;
    }
  } else {
    double random_size_mean_tmp = 1.0;
    random_size_mean = random_size_mean_tmp;
  }
  if (sub->NMatches("random_size_stddev") > 0) {
    {
      double random_size_stddev_val = cyclus::Query<double>(sub, "random_size_stddev");
      random_size_stddev = random_size_stddev_val;
    }
  } else {
    double random_size_stddev_tmp = 0.1;
    random_size_stddev = random_size_stddev_tmp;
  }
  if (sub->NMatches("random_frequency_type") > 0) {
    {
      std::string random_frequency_type_val = cyclus::Query<std::string>(sub, "random_frequency_type");
      random_frequency_type = random_frequency_type_val;
    }
  } else {
    std::string random_frequency_type_tmp("None");
    random_frequency_type = random_frequency_type_tmp;
  }
  if (sub->NMatches("random_frequency_mean") > 0) {
    {
      double random_frequency_mean_val = cyclus::Query<double>(sub, "random_frequency_mean");
      random_frequency_mean = random_frequency_mean_val;
    }
  } else {
    double random_frequency_mean_tmp = 1;
    random_frequency_mean = random_frequency_mean_tmp;
  }
  if (sub->NMatches("random_frequency_stddev") > 0) {
    {
      double random_frequency_stddev_val = cyclus::Query<double>(sub, "random_frequency_stddev");
      random_frequency_stddev = random_frequency_stddev_val;
    }
  } else {
    double random_frequency_stddev_tmp = 1;
    random_frequency_stddev = random_frequency_stddev_tmp;
  }
  if (sub->NMatches("random_frequency_min") > 0) {
    {
      int random_frequency_min_val = cyclus::Query<int>(sub, "random_frequency_min");
      random_frequency_min = random_frequency_min_val;
    }
  } else {
    int random_frequency_min_tmp = 1;
    random_frequency_min = random_frequency_min_tmp;
  }
  if (sub->NMatches("random_frequency_max") > 0) {
    {
      int random_frequency_max_val = cyclus::Query<int>(sub, "random_frequency_max");
      random_frequency_max = random_frequency_max_val;
    }
  } else {
    int random_frequency_max_tmp = 2147483647;
    random_frequency_max = random_frequency_max_tmp;
  }
  if (sub->NMatches("keep_packaging") > 0) {
    {
      bool keep_packaging_val = cyclus::Query<bool>(sub, "keep_packaging");
      keep_packaging = keep_packaging_val;
    }
  } else {
    bool keep_packaging_tmp = true;
    keep_packaging = keep_packaging_tmp;
  }
  di.NewDatum("Info")
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->AddVal("in_commods", in_commods, &cycpp_shape_in_commods)
  ->AddVal("in_commod_prefs", in_commod_prefs, &cycpp_shape_in_commod_prefs)
  ->AddVal("recipe_name", recipe_name, &cycpp_shape_recipe_name)
  ->AddVal("max_inv_size", max_inv_size, &cycpp_shape_max_inv_size)
  ->AddVal("capacity", capacity, &cycpp_shape_capacity)
  ->AddVal("random_size_type", random_size_type, &cycpp_shape_random_size_type)
  ->AddVal("random_size_mean", random_size_mean, &cycpp_shape_random_size_mean)
  ->AddVal("random_size_stddev", random_size_stddev, &cycpp_shape_random_size_stddev)
  ->AddVal("random_frequency_type", random_frequency_type, &cycpp_shape_random_frequency_type)
  ->AddVal("random_frequency_mean", random_frequency_mean, &cycpp_shape_random_frequency_mean)
  ->AddVal("random_frequency_stddev", random_frequency_stddev, &cycpp_shape_random_frequency_stddev)
  ->AddVal("random_frequency_min", random_frequency_min, &cycpp_shape_random_frequency_min)
  ->AddVal("random_frequency_max", random_frequency_max, &cycpp_shape_random_frequency_max)
  ->AddVal("keep_packaging", keep_packaging, &cycpp_shape_keep_packaging)
  ->Record();
};
#line 24 "/cycamore/src/sink.cc"
 
void Sink::Snapshot(cyclus::DbInit di) {
  di.NewDatum("Info")
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->AddVal("in_commods", in_commods, &cycpp_shape_in_commods)
  ->AddVal("in_commod_prefs", in_commod_prefs, &cycpp_shape_in_commod_prefs)
  ->AddVal("recipe_name", recipe_name, &cycpp_shape_recipe_name)
  ->AddVal("max_inv_size", max_inv_size, &cycpp_shape_max_inv_size)
  ->AddVal("capacity", capacity, &cycpp_shape_capacity)
  ->AddVal("random_size_type", random_size_type, &cycpp_shape_random_size_type)
  ->AddVal("random_size_mean", random_size_mean, &cycpp_shape_random_size_mean)
  ->AddVal("random_size_stddev", random_size_stddev, &cycpp_shape_random_size_stddev)
  ->AddVal("random_frequency_type", random_frequency_type, &cycpp_shape_random_frequency_type)
  ->AddVal("random_frequency_mean", random_frequency_mean, &cycpp_shape_random_frequency_mean)
  ->AddVal("random_frequency_stddev", random_frequency_stddev, &cycpp_shape_random_frequency_stddev)
  ->AddVal("random_frequency_min", random_frequency_min, &cycpp_shape_random_frequency_min)
  ->AddVal("random_frequency_max", random_frequency_max, &cycpp_shape_random_frequency_max)
  ->AddVal("keep_packaging", keep_packaging, &cycpp_shape_keep_packaging)
  ->Record();
};
#line 26 "/cycamore/src/sink.cc"
 
cyclus::Inventories Sink::SnapshotInv() {
  cyclus::Inventories invs;
  invs["inventory"] = inventory.PopNRes(inventory.count());
  inventory.Push(invs["inventory"]);
  return invs;
};
#line 28 "/cycamore/src/sink.cc"
 
void Sink::InitInv(cyclus::Inventories& inv) {
  inventory.Push(inv["inventory"]);
  
};
#line 30 "/cycamore/src/sink.cc"
 
cyclus::Agent* Sink::Clone() {
  cycamore::Sink* m = new cycamore::Sink(context());
  m->InitFrom(this);
  return m;
};
#line 32 "/cycamore/src/sink.cc"
 
void Sink::InitFrom(cyclus::QueryableBackend* b) {
  cyclus::Facility::InitFrom(b);
  int rawcycpp_shape_latitude[1] = {-1};
  cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
  int rawcycpp_shape_longitude[1] = {-1};
  cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
  int rawcycpp_shape_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_recipe_name[1] = {-1};
  cycpp_shape_recipe_name = std::vector<int>(rawcycpp_shape_recipe_name, rawcycpp_shape_recipe_name + 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_capacity[1] = {-1};
  cycpp_shape_capacity = std::vector<int>(rawcycpp_shape_capacity, rawcycpp_shape_capacity + 1);
  int rawcycpp_shape_inventory[2] = {-1, -1};
  cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
  int rawcycpp_shape_random_size_type[1] = {-1};
  cycpp_shape_random_size_type = std::vector<int>(rawcycpp_shape_random_size_type, rawcycpp_shape_random_size_type + 1);
  int rawcycpp_shape_random_size_mean[1] = {-1};
  cycpp_shape_random_size_mean = std::vector<int>(rawcycpp_shape_random_size_mean, rawcycpp_shape_random_size_mean + 1);
  int rawcycpp_shape_random_size_stddev[1] = {-1};
  cycpp_shape_random_size_stddev = std::vector<int>(rawcycpp_shape_random_size_stddev, rawcycpp_shape_random_size_stddev + 1);
  int rawcycpp_shape_random_frequency_type[1] = {-1};
  cycpp_shape_random_frequency_type = std::vector<int>(rawcycpp_shape_random_frequency_type, rawcycpp_shape_random_frequency_type + 1);
  int rawcycpp_shape_random_frequency_mean[1] = {-1};
  cycpp_shape_random_frequency_mean = std::vector<int>(rawcycpp_shape_random_frequency_mean, rawcycpp_shape_random_frequency_mean + 1);
  int rawcycpp_shape_random_frequency_stddev[1] = {-1};
  cycpp_shape_random_frequency_stddev = std::vector<int>(rawcycpp_shape_random_frequency_stddev, rawcycpp_shape_random_frequency_stddev + 1);
  int rawcycpp_shape_random_frequency_min[1] = {-1};
  cycpp_shape_random_frequency_min = std::vector<int>(rawcycpp_shape_random_frequency_min, rawcycpp_shape_random_frequency_min + 1);
  int rawcycpp_shape_random_frequency_max[1] = {-1};
  cycpp_shape_random_frequency_max = std::vector<int>(rawcycpp_shape_random_frequency_max, rawcycpp_shape_random_frequency_max + 1);
  int rawcycpp_shape_keep_packaging[1] = {-1};
  cycpp_shape_keep_packaging = std::vector<int>(rawcycpp_shape_keep_packaging, rawcycpp_shape_keep_packaging + 1);
  cyclus::QueryResult qr = b->Query("Info", NULL);
  latitude = qr.GetVal<double>("latitude");
  longitude = qr.GetVal<double>("longitude");
  in_commods = qr.GetVal<std::vector< std::string > >("in_commods");
  in_commod_prefs = qr.GetVal<std::vector< double > >("in_commod_prefs");
  recipe_name = qr.GetVal<std::string>("recipe_name");
  max_inv_size = qr.GetVal<double>("max_inv_size");
  capacity = qr.GetVal<double>("capacity");
  random_size_type = qr.GetVal<std::string>("random_size_type");
  random_size_mean = qr.GetVal<double>("random_size_mean");
  random_size_stddev = qr.GetVal<double>("random_size_stddev");
  random_frequency_type = qr.GetVal<std::string>("random_frequency_type");
  random_frequency_mean = qr.GetVal<double>("random_frequency_mean");
  random_frequency_stddev = qr.GetVal<double>("random_frequency_stddev");
  random_frequency_min = qr.GetVal<int>("random_frequency_min");
  random_frequency_max = qr.GetVal<int>("random_frequency_max");
  keep_packaging = qr.GetVal<bool>("keep_packaging");
  inventory.capacity(max_inv_size);
};
#line 34 "/cycamore/src/sink.cc"
 
void Sink::InitFrom(cycamore::Sink* m) {
  cyclus::Facility::InitFrom(m);
  int rawcycpp_shape_latitude[1] = {-1};
  cycpp_shape_latitude = std::vector<int>(rawcycpp_shape_latitude, rawcycpp_shape_latitude + 1);
  int rawcycpp_shape_longitude[1] = {-1};
  cycpp_shape_longitude = std::vector<int>(rawcycpp_shape_longitude, rawcycpp_shape_longitude + 1);
  int rawcycpp_shape_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_recipe_name[1] = {-1};
  cycpp_shape_recipe_name = std::vector<int>(rawcycpp_shape_recipe_name, rawcycpp_shape_recipe_name + 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_capacity[1] = {-1};
  cycpp_shape_capacity = std::vector<int>(rawcycpp_shape_capacity, rawcycpp_shape_capacity + 1);
  int rawcycpp_shape_inventory[2] = {-1, -1};
  cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
  int rawcycpp_shape_random_size_type[1] = {-1};
  cycpp_shape_random_size_type = std::vector<int>(rawcycpp_shape_random_size_type, rawcycpp_shape_random_size_type + 1);
  int rawcycpp_shape_random_size_mean[1] = {-1};
  cycpp_shape_random_size_mean = std::vector<int>(rawcycpp_shape_random_size_mean, rawcycpp_shape_random_size_mean + 1);
  int rawcycpp_shape_random_size_stddev[1] = {-1};
  cycpp_shape_random_size_stddev = std::vector<int>(rawcycpp_shape_random_size_stddev, rawcycpp_shape_random_size_stddev + 1);
  int rawcycpp_shape_random_frequency_type[1] = {-1};
  cycpp_shape_random_frequency_type = std::vector<int>(rawcycpp_shape_random_frequency_type, rawcycpp_shape_random_frequency_type + 1);
  int rawcycpp_shape_random_frequency_mean[1] = {-1};
  cycpp_shape_random_frequency_mean = std::vector<int>(rawcycpp_shape_random_frequency_mean, rawcycpp_shape_random_frequency_mean + 1);
  int rawcycpp_shape_random_frequency_stddev[1] = {-1};
  cycpp_shape_random_frequency_stddev = std::vector<int>(rawcycpp_shape_random_frequency_stddev, rawcycpp_shape_random_frequency_stddev + 1);
  int rawcycpp_shape_random_frequency_min[1] = {-1};
  cycpp_shape_random_frequency_min = std::vector<int>(rawcycpp_shape_random_frequency_min, rawcycpp_shape_random_frequency_min + 1);
  int rawcycpp_shape_random_frequency_max[1] = {-1};
  cycpp_shape_random_frequency_max = std::vector<int>(rawcycpp_shape_random_frequency_max, rawcycpp_shape_random_frequency_max + 1);
  int rawcycpp_shape_keep_packaging[1] = {-1};
  cycpp_shape_keep_packaging = std::vector<int>(rawcycpp_shape_keep_packaging, rawcycpp_shape_keep_packaging + 1);
  latitude = m->latitude;
  longitude = m->longitude;
  in_commods = m->in_commods;
  in_commod_prefs = m->in_commod_prefs;
  recipe_name = m->recipe_name;
  max_inv_size = m->max_inv_size;
  capacity = m->capacity;
  random_size_type = m->random_size_type;
  random_size_mean = m->random_size_mean;
  random_size_stddev = m->random_size_stddev;
  random_frequency_type = m->random_frequency_type;
  random_frequency_mean = m->random_frequency_mean;
  random_frequency_stddev = m->random_frequency_stddev;
  random_frequency_min = m->random_frequency_min;
  random_frequency_max = m->random_frequency_max;
  keep_packaging = m->keep_packaging;
  inventory.capacity(m->inventory.capacity());
};
#line 38 "/cycamore/src/sink.cc"
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Sink::EnterNotify() {
  cyclus::Facility::EnterNotify();
  LOG(cyclus::LEV_INFO4, "SnkFac") << " using random behavior " << random_size_type;
 
  inventory.keep_packaging(keep_packaging);
 
  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());
  }
  SetRequestAmt();
  SetNextBuyTime();
 
  if (random_size_type != "None") {
    LOG(cyclus::LEV_INFO4, "SnkFac") << "Sink " << this->id()
                                     << " is using random behavior "
                                     << random_size_type
                                     << " for determining request size.";
  }
  if (random_frequency_type != "None") {
    LOG(cyclus::LEV_INFO4, "SnkFac") << "Sink " << this->id()
                                     << " is using random behavior "
                                     << random_frequency_type
                                     << " for determining request frequency.";
  }
 
  InitializePosition();
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::string Sink::str() {
  using std::string;
  using std::vector;
  std::stringstream ss;
  ss << cyclus::Facility::str();
 
  string msg = "";
  msg += "accepts commodities ";
  for (vector<string>::iterator commod = in_commods.begin();
       commod != in_commods.end();
       commod++) {
    msg += (commod == in_commods.begin() ? "{" : ", ");
    msg += (*commod);
  }
  msg += "} until its inventory is full at ";
  ss << msg << inventory.capacity() << " kg.";
  return "" + ss.str();
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::set<cyclus::RequestPortfolio<cyclus::Material>::Ptr>
Sink::GetMatlRequests() {
  using cyclus::Material;
  using cyclus::RequestPortfolio;
  using cyclus::Request;
  using cyclus::Composition;
 
  std::set<RequestPortfolio<Material>::Ptr> ports;
  RequestPortfolio<Material>::Ptr port(new RequestPortfolio<Material>());
  Material::Ptr mat;

  if (requestAmt > SpaceAvailable()) {
    SetRequestAmt();
  }
 
  if (recipe_name.empty()) {
    mat = cyclus::NewBlankMaterial(requestAmt);
  } else {
    Composition::Ptr rec = this->context()->GetRecipe(recipe_name);
    mat = cyclus::Material::CreateUntracked(requestAmt, rec);
  }
 
  if (requestAmt > cyclus::eps()) {  
    std::vector<Request<Material>*> mutuals;
    for (int i = 0; i < in_commods.size(); i++) {
      mutuals.push_back(port->AddRequest(mat, this, in_commods[i], in_commod_prefs[i]));
 
    }
    port->AddMutualReqs(mutuals);
    ports.insert(port);
  }  // if amt > eps
  return ports;
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::set<cyclus::RequestPortfolio<cyclus::Product>::Ptr>
Sink::GetGenRsrcRequests() {
  using cyclus::CapacityConstraint;
  using cyclus::Product;
  using cyclus::RequestPortfolio;
 
  std::set<RequestPortfolio<Product>::Ptr> ports;
  RequestPortfolio<Product>::Ptr
      port(new RequestPortfolio<Product>());
 
  if (requestAmt > cyclus::eps()) {
    CapacityConstraint<Product> cc(requestAmt);
    port->AddConstraint(cc);
 
    std::vector<std::string>::const_iterator it;
    for (it = in_commods.begin(); it != in_commods.end(); ++it) {
      std::string quality = "";  // not clear what this should be..
      Product::Ptr rsrc = Product::CreateUntracked(requestAmt, quality);
      port->AddRequest(rsrc, this, *it);
    }
 
    ports.insert(port);
  }  // if amt > eps
  return ports;
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Sink::AcceptMatlTrades(
    const std::vector< std::pair<cyclus::Trade<cyclus::Material>,
                                 cyclus::Material::Ptr> >& responses) {
  std::vector< std::pair<cyclus::Trade<cyclus::Material>,
                         cyclus::Material::Ptr> >::const_iterator it;
  for (it = responses.begin(); it != responses.end(); ++it) {
    inventory.Push(it->second);
  }
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Sink::AcceptGenRsrcTrades(
    const std::vector< std::pair<cyclus::Trade<cyclus::Product>,
                                 cyclus::Product::Ptr> >& responses) {
  std::vector< std::pair<cyclus::Trade<cyclus::Product>,
                         cyclus::Product::Ptr> >::const_iterator it;
  for (it = responses.begin(); it != responses.end(); ++it) {
    inventory.Push(it->second);
  }
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Sink::Tick() {
  using std::string;
  using std::vector;
  LOG(cyclus::LEV_INFO3, "SnkFac") << "Sink " << this->id() << " is ticking {";
 
  if (nextBuyTime == -1) {
    SetRequestAmt();
  }
  else if (nextBuyTime == context()->time()) {
    SetRequestAmt();
    SetNextBuyTime();
 
    LOG(cyclus::LEV_INFO4, "SnkFac") << "Sink " << this->id() 
                                     << " has reached buying time. The next buy time will be time step " << nextBuyTime;
  }
  else {
    requestAmt = 0;
  }
 
  // inform the simulation about what the sink facility will be requesting
  if (requestAmt > cyclus::eps()) {
    LOG(cyclus::LEV_INFO4, "SnkFac") << "Sink " << this->id()
                                     << " has request amount " << requestAmt
                                     << " kg of " << in_commods[0] << ".";
    for (vector<string>::iterator commod = in_commods.begin();
         commod != in_commods.end();
         commod++) {
      LOG(cyclus::LEV_INFO4, "SnkFac") << "Sink " << this->id() 
                                       << " will request " << requestAmt
                                       << " kg of " << *commod << ".";
      cyclus::toolkit::RecordTimeSeries<double>("demand"+*commod, this,
                                            requestAmt);
    }
  }
  LOG(cyclus::LEV_INFO3, "SnkFac") << "}";
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Sink::Tock() {
  LOG(cyclus::LEV_INFO3, "SnkFac") << prototype() << " is tocking {";
 
  // On the tock, the sink facility doesn't really do much.
  // Maybe someday it will record things.
  // For now, lets just print out what we have at each timestep.
  LOG(cyclus::LEV_INFO4, "SnkFac") << "Sink " << this->id()
                                   << " is holding " << inventory.quantity()
                                   << " units of material at the close of timestep "
                                   << context()->time() << ".";
  LOG(cyclus::LEV_INFO3, "SnkFac") << "}";
}
 
void Sink::SetRequestAmt() {
  double amt = SpaceAvailable();
  if (amt < cyclus::eps()) {
    requestAmt = 0;
  }
 
  if (random_size_type == "None") {
    requestAmt =  amt;
  }
  else if (random_size_type == "UniformReal") {
    requestAmt =  context()->random_uniform_real(0, amt);
  }
  else if (random_size_type == "NormalReal") {
    requestAmt =  context()->random_normal_real(amt * random_size_mean,
                                                amt * random_size_stddev, 
                                                0, amt);
  }
  else {
    requestAmt =  amt;
  }
  return;
}
 
void Sink::SetNextBuyTime() {
  if (random_frequency_type == "None") {
    nextBuyTime = -1;
  }
  else if (random_frequency_type == "UniformInt") {
    nextBuyTime = context()->time() + context()->random_uniform_int(random_frequency_min, random_frequency_max);
  }
  else if (random_frequency_type == "NormalInt") {
    nextBuyTime = context()->time() + context()->random_normal_int(random_frequency_mean, random_frequency_stddev, random_frequency_min, random_frequency_max);
  }
  else {
    nextBuyTime = -1;
  }
  return;
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
extern "C" cyclus::Agent* ConstructSink(cyclus::Context* ctx) {
  return new Sink(ctx);
}
 
}  // namespace cycamore