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()),
      latitude(0.0),
      longitude(0.0),
      keep_packaging(true),
      coordinates(latitude, longitude) {
  SetMaxInventorySize(std::numeric_limits<double>::max());}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Sink::~Sink() {}
std::string Sink::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"
    "    <optional>\n"
    "        <element name=\"recipe_name\">\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"max_inv_size\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"capacity\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_size_type\">\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_size_mean\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_size_stddev\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_type\">\n"
    "            <data type=\"string\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_mean\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_stddev\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_min\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"random_frequency_max\">\n"
    "            <data type=\"int\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"keep_packaging\">\n"
    "            <data type=\"boolean\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"latitude\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"longitude\">\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "</interleave>\n";
};
#line 23 "/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\":[\"cyclus::Agent\",\"cyclus::Facili"
    "ty\",\"cyclus::Ider\",\"cyclus::StateWrangler\",\"cyclus"
    "::TimeListener\",\"cyclus::Trader\",\"cyclus::toolkit:"
    ":Position\"],\"vars\":{\"in_commods\":{\"tooltip\":[\"inpu"
    "t commodities\",\"\"],\"doc\":\"commodities that the "
    "sink facility accepts\",\"uilabel\":[\"List of Input C"
    "ommodities\",\"\"],\"uitype\":[\"oneormore\",\"incommodity"
    "\"],\"type\":[\"std::vector\",\"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\",\"\"]},\"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\":2,\"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\":3,\"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\":4,\"shape\":"
    "[-"
    "1],\"alias\":\"capacity\"},\"inventory\":{\"capacity\":\"ma"
    "x_inv_size\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyc"
    "lus::Resource\"],\"index\":5,\"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\":6,\"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\":7,\"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\":8"
    ",\"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\":9,\"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\":10,\"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\":11,"
    "\"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"
    "2,\"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\":13,\"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\":14,\"shape\":[-"
    "1],\"alias\":\"keep_packaging\"},\"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\":15,\"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\":16,\"shape\":[-"
    "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"}},\"do"
    "c\":\" 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 25 "/cycamore/src/sink.cc"
 
void Sink::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_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);
  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;
  }
  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;
  }
  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("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)
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->Record();
};
#line 27 "/cycamore/src/sink.cc"
 
void Sink::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("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)
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->Record();
};
#line 29 "/cycamore/src/sink.cc"
 
cyclus::Inventories Sink::SnapshotInv() {
  cyclus::Inventories invs;
  invs["inventory"] = inventory.PopNRes(inventory.count());
  inventory.Push(invs["inventory"]);
  return invs;
};
#line 31 "/cycamore/src/sink.cc"
 
void Sink::InitInv(cyclus::Inventories& inv) {
  inventory.Push(inv["inventory"]);
  
};
#line 33 "/cycamore/src/sink.cc"
 
cyclus::Agent* Sink::Clone() {
  cycamore::Sink* m = new cycamore::Sink(context());
  m->InitFrom(this);
  return m;
};
#line 35 "/cycamore/src/sink.cc"
 
void Sink::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_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);
  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");
  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");
  latitude = qr.GetVal<double>("latitude");
  longitude = qr.GetVal<double>("longitude");
  inventory.capacity(max_inv_size);
};
#line 37 "/cycamore/src/sink.cc"
 
void Sink::InitFrom(cycamore::Sink* 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_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);
  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;
  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;
  latitude = m->latitude;
  longitude = m->longitude;
  inventory.capacity(m->inventory.capacity());
};
#line 41 "/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.";
  }
  RecordPosition();
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
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::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();
}
 
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