build/cycamore/enrichment.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/enrichment.h"
#ifndef CYCAMORE_SRC_ENRICHMENT_H_
#define CYCAMORE_SRC_ENRICHMENT_H_
 
#include <string>
 
#include "cyclus.h"
#include "cycamore_version.h"
 
#pragma cyclus exec from cyclus.system import CY_LARGE_DOUBLE, CY_LARGE_INT, CY_NEAR_ZERO
 
namespace cycamore {
 
class SWUConverter : public cyclus::Converter<cyclus::Material> {
 public:
  SWUConverter(double feed_commod, double tails) : feed_(feed_commod),
    tails_(tails) {}
  virtual ~SWUConverter() {}
 
  virtual double convert(
      cyclus::Material::Ptr m,
      cyclus::Arc const * a = NULL,
      cyclus::ExchangeTranslationContext<cyclus::Material>
          const * ctx = NULL) const {
    cyclus::toolkit::Assays assays(feed_, cyclus::toolkit::UraniumAssayMass(m),
                                   tails_);
    return cyclus::toolkit::SwuRequired(m->quantity(), assays);
  }
 
  virtual bool operator==(Converter& other) const {
    SWUConverter* cast = dynamic_cast<SWUConverter*>(&other);
    return cast != NULL &&
    feed_ == cast->feed_ &&
    tails_ == cast->tails_;
  }
 
 private:
  double feed_, tails_;
};
 
class NatUConverter : public cyclus::Converter<cyclus::Material> {
 public:
  NatUConverter(double feed_commod, double tails) : feed_(feed_commod),
    tails_(tails) {}
  virtual ~NatUConverter() {}
 
  virtual std::string version() { return CYCAMORE_VERSION; }
 
  virtual double convert(
      cyclus::Material::Ptr m,
      cyclus::Arc const * a = NULL,
      cyclus::ExchangeTranslationContext<cyclus::Material>
          const * ctx = NULL) const {
    cyclus::toolkit::Assays assays(feed_, cyclus::toolkit::UraniumAssayMass(m),
                                   tails_);
    cyclus::toolkit::MatQuery mq(m);
    std::set<cyclus::Nuc> nucs;
    nucs.insert(922350000);
    nucs.insert(922380000);
 
    double natu_frac = mq.mass_frac(nucs);
    double natu_req = cyclus::toolkit::FeedQty(m->quantity(), assays);
    return natu_req / natu_frac;
  }
 
  virtual bool operator==(Converter& other) const {
    NatUConverter* cast = dynamic_cast<NatUConverter*>(&other);
    return cast != NULL &&
    feed_ == cast->feed_ &&
    tails_ == cast->tails_;
  }
 
 private:
  double feed_, tails_;
};
 
 
class Enrichment
  : public cyclus::Facility,
    public cyclus::toolkit::Position {
#pragma cyclus note {               "niche": "enrichment facility",                                 "doc":                                                                "The Enrichment facility is a simple agent that enriches natural "       "uranium in a Cyclus simulation. It does not explicitly compute "      "the physical enrichment process, rather it calculates the SWU "        "required to convert a source uranium recipe (i.e. natural uranium) "   "into a requested enriched recipe (i.e. 4% enriched uranium), given "   "the natural uranium inventory constraint and its SWU capacity "   "constraint."                                                        "\n\n"                                                                  "The Enrichment facility requests an input commodity and associated "   "recipe whose quantity is its remaining inventory capacity.  All "   "facilities trading the same input commodity (even with different "   "recipes) will offer materials for trade.  The Enrichment facility "   "accepts any input materials with enrichments less than its tails assay, "  "as long as some U235 is present, and preference increases with U235 "   "content.  If no U235 is present in the offered material, the trade "   "preference is set to -1 and the material is not accepted.  Any material "   "components other than U235 and U238 are sent directly to the tails buffer."  "\n\n"                                                                "The Enrichment facility will bid on any request for its output commodity "  "up to the maximum allowed enrichment (if not specified, default is 100%) "  "It bids on either the request quantity, or the maximum quanity allowed "   "by its SWU constraint or natural uranium inventory, whichever is lower. "   "If multiple output commodities with different enrichment levels are "   "requested and the facility does not have the SWU or quantity capacity "   "to meet all requests, the requests are fully, then partially filled "   "in unspecified but repeatable order. A request for the product "   "commodity without an associated requested enriched recipe will not be "   "fulfilled."                             "\n\n"                                                                  "Accumulated tails inventory is offered for trading as a specifiable "   "output commodity.", }
#line 160 "/cycamore/src/enrichment.h"
 public:
  // --- Module Members ---
  Enrichment(cyclus::Context* ctx);
 
  virtual ~Enrichment();
 
  virtual std::string version() { return CYCAMORE_VERSION; }
  virtual void InitFrom(cycamore::Enrichment* m) {
    cyclus::Facility::InitFrom(m);
    int rawcycpp_shape_feed_commod[1] = {-1};
    cycpp_shape_feed_commod = std::vector<int>(rawcycpp_shape_feed_commod, rawcycpp_shape_feed_commod + 1);
    int rawcycpp_shape_feed_recipe[1] = {-1};
    cycpp_shape_feed_recipe = std::vector<int>(rawcycpp_shape_feed_recipe, rawcycpp_shape_feed_recipe + 1);
    int rawcycpp_shape_product_commod[1] = {-1};
    cycpp_shape_product_commod = std::vector<int>(rawcycpp_shape_product_commod, rawcycpp_shape_product_commod + 1);
    int rawcycpp_shape_tails_commod[1] = {-1};
    cycpp_shape_tails_commod = std::vector<int>(rawcycpp_shape_tails_commod, rawcycpp_shape_tails_commod + 1);
    int rawcycpp_shape_tails_assay[1] = {-1};
    cycpp_shape_tails_assay = std::vector<int>(rawcycpp_shape_tails_assay, rawcycpp_shape_tails_assay + 1);
    int rawcycpp_shape_initial_feed[1] = {-1};
    cycpp_shape_initial_feed = std::vector<int>(rawcycpp_shape_initial_feed, rawcycpp_shape_initial_feed + 1);
    int rawcycpp_shape_max_feed_inventory[1] = {-1};
    cycpp_shape_max_feed_inventory = std::vector<int>(rawcycpp_shape_max_feed_inventory, rawcycpp_shape_max_feed_inventory + 1);
    int rawcycpp_shape_max_enrich[1] = {-1};
    cycpp_shape_max_enrich = std::vector<int>(rawcycpp_shape_max_enrich, rawcycpp_shape_max_enrich + 1);
    int rawcycpp_shape_order_prefs[1] = {-1};
    cycpp_shape_order_prefs = std::vector<int>(rawcycpp_shape_order_prefs, rawcycpp_shape_order_prefs + 1);
    int rawcycpp_shape_swu_capacity[1] = {-1};
    cycpp_shape_swu_capacity = std::vector<int>(rawcycpp_shape_swu_capacity, rawcycpp_shape_swu_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_tails[2] = {-1, -1};
    cycpp_shape_tails = std::vector<int>(rawcycpp_shape_tails, rawcycpp_shape_tails + 2);
    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);
    feed_commod = m->feed_commod;
    feed_recipe = m->feed_recipe;
    product_commod = m->product_commod;
    tails_commod = m->tails_commod;
    tails_assay = m->tails_assay;
    initial_feed = m->initial_feed;
    max_feed_inventory = m->max_feed_inventory;
    max_enrich = m->max_enrich;
    order_prefs = m->order_prefs;
    swu_capacity = m->swu_capacity;
    latitude = m->latitude;
    longitude = m->longitude;
    inventory.capacity(m->inventory.capacity());
    tails.capacity(m->tails.capacity());
  };
#line 170 "/cycamore/src/enrichment.h"
 
  virtual void InitFrom(cyclus::QueryableBackend* b) {
    cyclus::Facility::InitFrom(b);
    int rawcycpp_shape_feed_commod[1] = {-1};
    cycpp_shape_feed_commod = std::vector<int>(rawcycpp_shape_feed_commod, rawcycpp_shape_feed_commod + 1);
    int rawcycpp_shape_feed_recipe[1] = {-1};
    cycpp_shape_feed_recipe = std::vector<int>(rawcycpp_shape_feed_recipe, rawcycpp_shape_feed_recipe + 1);
    int rawcycpp_shape_product_commod[1] = {-1};
    cycpp_shape_product_commod = std::vector<int>(rawcycpp_shape_product_commod, rawcycpp_shape_product_commod + 1);
    int rawcycpp_shape_tails_commod[1] = {-1};
    cycpp_shape_tails_commod = std::vector<int>(rawcycpp_shape_tails_commod, rawcycpp_shape_tails_commod + 1);
    int rawcycpp_shape_tails_assay[1] = {-1};
    cycpp_shape_tails_assay = std::vector<int>(rawcycpp_shape_tails_assay, rawcycpp_shape_tails_assay + 1);
    int rawcycpp_shape_initial_feed[1] = {-1};
    cycpp_shape_initial_feed = std::vector<int>(rawcycpp_shape_initial_feed, rawcycpp_shape_initial_feed + 1);
    int rawcycpp_shape_max_feed_inventory[1] = {-1};
    cycpp_shape_max_feed_inventory = std::vector<int>(rawcycpp_shape_max_feed_inventory, rawcycpp_shape_max_feed_inventory + 1);
    int rawcycpp_shape_max_enrich[1] = {-1};
    cycpp_shape_max_enrich = std::vector<int>(rawcycpp_shape_max_enrich, rawcycpp_shape_max_enrich + 1);
    int rawcycpp_shape_order_prefs[1] = {-1};
    cycpp_shape_order_prefs = std::vector<int>(rawcycpp_shape_order_prefs, rawcycpp_shape_order_prefs + 1);
    int rawcycpp_shape_swu_capacity[1] = {-1};
    cycpp_shape_swu_capacity = std::vector<int>(rawcycpp_shape_swu_capacity, rawcycpp_shape_swu_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_tails[2] = {-1, -1};
    cycpp_shape_tails = std::vector<int>(rawcycpp_shape_tails, rawcycpp_shape_tails + 2);
    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);
    feed_commod = qr.GetVal<std::string>("feed_commod");
    feed_recipe = qr.GetVal<std::string>("feed_recipe");
    product_commod = qr.GetVal<std::string>("product_commod");
    tails_commod = qr.GetVal<std::string>("tails_commod");
    tails_assay = qr.GetVal<double>("tails_assay");
    initial_feed = qr.GetVal<double>("initial_feed");
    max_feed_inventory = qr.GetVal<double>("max_feed_inventory");
    max_enrich = qr.GetVal<double>("max_enrich");
    order_prefs = qr.GetVal<bool>("order_prefs");
    swu_capacity = qr.GetVal<double>("swu_capacity");
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
    inventory.capacity(max_feed_inventory);
    tails.capacity(1e+300);
  };
 
  virtual void InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
    cyclus::Facility::InfileToDb(tree, di);
    int rawcycpp_shape_feed_commod[1] = {-1};
    cycpp_shape_feed_commod = std::vector<int>(rawcycpp_shape_feed_commod, rawcycpp_shape_feed_commod + 1);
    int rawcycpp_shape_feed_recipe[1] = {-1};
    cycpp_shape_feed_recipe = std::vector<int>(rawcycpp_shape_feed_recipe, rawcycpp_shape_feed_recipe + 1);
    int rawcycpp_shape_product_commod[1] = {-1};
    cycpp_shape_product_commod = std::vector<int>(rawcycpp_shape_product_commod, rawcycpp_shape_product_commod + 1);
    int rawcycpp_shape_tails_commod[1] = {-1};
    cycpp_shape_tails_commod = std::vector<int>(rawcycpp_shape_tails_commod, rawcycpp_shape_tails_commod + 1);
    int rawcycpp_shape_tails_assay[1] = {-1};
    cycpp_shape_tails_assay = std::vector<int>(rawcycpp_shape_tails_assay, rawcycpp_shape_tails_assay + 1);
    int rawcycpp_shape_initial_feed[1] = {-1};
    cycpp_shape_initial_feed = std::vector<int>(rawcycpp_shape_initial_feed, rawcycpp_shape_initial_feed + 1);
    int rawcycpp_shape_max_feed_inventory[1] = {-1};
    cycpp_shape_max_feed_inventory = std::vector<int>(rawcycpp_shape_max_feed_inventory, rawcycpp_shape_max_feed_inventory + 1);
    int rawcycpp_shape_max_enrich[1] = {-1};
    cycpp_shape_max_enrich = std::vector<int>(rawcycpp_shape_max_enrich, rawcycpp_shape_max_enrich + 1);
    int rawcycpp_shape_order_prefs[1] = {-1};
    cycpp_shape_order_prefs = std::vector<int>(rawcycpp_shape_order_prefs, rawcycpp_shape_order_prefs + 1);
    int rawcycpp_shape_swu_capacity[1] = {-1};
    cycpp_shape_swu_capacity = std::vector<int>(rawcycpp_shape_swu_capacity, rawcycpp_shape_swu_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_tails[2] = {-1, -1};
    cycpp_shape_tails = std::vector<int>(rawcycpp_shape_tails, rawcycpp_shape_tails + 2);
    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;
    {
      std::string feed_commod_val = cyclus::Query<std::string>(sub, "feed_commod");
      feed_commod = feed_commod_val;
    }
    {
      std::string feed_recipe_val = cyclus::Query<std::string>(sub, "feed_recipe");
      feed_recipe = feed_recipe_val;
    }
    {
      std::string product_commod_val = cyclus::Query<std::string>(sub, "product_commod");
      product_commod = product_commod_val;
    }
    {
      std::string tails_commod_val = cyclus::Query<std::string>(sub, "tails_commod");
      tails_commod = tails_commod_val;
    }
    if (sub->NMatches("tails_assay") > 0) {
      {
        double tails_assay_val = cyclus::Query<double>(sub, "tails_assay");
        tails_assay = tails_assay_val;
      }
    } else {
      double tails_assay_tmp = 0.003;
      tails_assay = tails_assay_tmp;
    }
    if (sub->NMatches("initial_feed") > 0) {
      {
        double initial_feed_val = cyclus::Query<double>(sub, "initial_feed");
        initial_feed = initial_feed_val;
      }
    } else {
      double initial_feed_tmp = 0;
      initial_feed = initial_feed_tmp;
    }
    if (sub->NMatches("max_feed_inventory") > 0) {
      {
        double max_feed_inventory_val = cyclus::Query<double>(sub, "max_feed_inventory");
        max_feed_inventory = max_feed_inventory_val;
      }
    } else {
      double max_feed_inventory_tmp = 1e+299;
      max_feed_inventory = max_feed_inventory_tmp;
    }
    if (sub->NMatches("max_enrich") > 0) {
      {
        double max_enrich_val = cyclus::Query<double>(sub, "max_enrich");
        max_enrich = max_enrich_val;
      }
    } else {
      double max_enrich_tmp = 1.0;
      max_enrich = max_enrich_tmp;
    }
    if (sub->NMatches("order_prefs") > 0) {
      {
        bool order_prefs_val = cyclus::Query<bool>(sub, "order_prefs");
        order_prefs = order_prefs_val;
      }
    } else {
      bool order_prefs_tmp = true;
      order_prefs = order_prefs_tmp;
    }
    if (sub->NMatches("swu_capacity") > 0) {
      {
        double swu_capacity_val = cyclus::Query<double>(sub, "swu_capacity");
        swu_capacity = swu_capacity_val;
      }
    } else {
      double swu_capacity_tmp = 1e+299;
      swu_capacity = swu_capacity_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("feed_commod", feed_commod, &cycpp_shape_feed_commod)
    ->AddVal("feed_recipe", feed_recipe, &cycpp_shape_feed_recipe)
    ->AddVal("product_commod", product_commod, &cycpp_shape_product_commod)
    ->AddVal("tails_commod", tails_commod, &cycpp_shape_tails_commod)
    ->AddVal("tails_assay", tails_assay, &cycpp_shape_tails_assay)
    ->AddVal("initial_feed", initial_feed, &cycpp_shape_initial_feed)
    ->AddVal("max_feed_inventory", max_feed_inventory, &cycpp_shape_max_feed_inventory)
    ->AddVal("max_enrich", max_enrich, &cycpp_shape_max_enrich)
    ->AddVal("order_prefs", order_prefs, &cycpp_shape_order_prefs)
    ->AddVal("swu_capacity", swu_capacity, &cycpp_shape_swu_capacity)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
 
  virtual cyclus::Agent* Clone() {
    cycamore::Enrichment* m = new cycamore::Enrichment(context());
    m->InitFrom(this);
    return m;
  };
 
  virtual std::string schema() {
    return ""
      "<interleave>\n"
      "    <element name=\"feed_commod\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <element name=\"feed_recipe\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <element name=\"product_commod\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <element name=\"tails_commod\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"tails_assay\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"initial_feed\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"max_feed_inventory\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"max_enrich\">\n"
      "            <data type=\"double\">\n"
      "                <param name=\"minInclusive\">0</param>\n"
      "                <param name=\"maxInclusive\">1</param>\n"
      "            </data>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"order_prefs\">\n"
      "            <data type=\"boolean\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"swu_capacity\">\n"
      "            <data type=\"double\"/>\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";
  };
 
  virtual Json::Value annotations() {
    Json::Value root;
    Json::Reader reader;
    bool parsed_ok = reader.parse(
      "{\"name\":\"cycamore::Enrichment\",\"entity\":\"facility\""
      ",\"parents\":[\"cyclus::Facility\",\"cyclus::toolkit::P"
      "osition\"],\"all_parents\":[\"cyclus::Agent\",\"cyclus::"
      "Facility\",\"cyclus::Ider\",\"cyclus::StateWrangler\",\""
      "cyclus::TimeListener\",\"cyclus::Trader\",\"cyclus::to"
      "olkit::Position\"],\"vars\":{\"feed_commod\":{\"tooltip\""
      ":\"feed commodity\",\"doc\":\"feed commodity that the "
      "enrichment facility accepts\",\"uilabel\":\"Feed Commo"
      "dity\",\"uitype\":\"incommodity\",\"type\":\"std::string\","
      "\"index\":0,\"shape\":[-"
      "1],\"alias\":\"feed_commod\"},\"feed_recipe\":{\"tooltip\""
      ":\"feed recipe\",\"doc\":\"recipe for enrichment "
      "facility feed commodity\",\"uilabel\":\"Feed Recipe\",\""
      "uitype\":\"inrecipe\",\"type\":\"std::string\",\"index\":1,"
      "\"shape\":[-"
      "1],\"alias\":\"feed_recipe\"},\"product_commod\":{\"toolt"
      "ip\":\"product commodity\",\"doc\":\"product commodity "
      "that the enrichment facility "
      "generates\",\"uilabel\":\"Product Commodity\",\"uitype\":"
      "\"outcommodity\",\"type\":\"std::string\",\"index\":2,\"sha"
      "pe\":[-"
      "1],\"alias\":\"product_commod\"},\"tails_commod\":{\"tool"
      "tip\":\"tails commodity\",\"doc\":\"tails commodity "
      "supplied by enrichment facility\",\"uilabel\":\"Tails "
      "Commodity\",\"uitype\":\"outcommodity\",\"type\":\"std::st"
      "ring\",\"index\":3,\"shape\":[-"
      "1],\"alias\":\"tails_commod\"},\"tails_assay\":{\"default"
      "\":0.003,\"tooltip\":\"tails assay\",\"uilabel\":\"Tails A"
      "ssay\",\"uitype\":\"range\",\"range\":[0.0,0.003],\"doc\":\""
      "tails assay from the enrichment process\",\"type\":\"d"
      "ouble\",\"index\":4,\"shape\":[-"
      "1],\"alias\":\"tails_assay\"},\"initial_feed\":{\"default"
      "\":0,\"tooltip\":\"initial uranium reserves "
      "(kg)\",\"uilabel\":\"Initial Feed "
      "Inventory\",\"doc\":\"amount of natural uranium stored"
      " at the enrichment facility at the beginning of "
      "the simulation (kg)\",\"type\":\"double\",\"index\":5,\"sh"
      "ape\":[-"
      "1],\"alias\":\"initial_feed\"},\"max_feed_inventory\":{\""
      "default\":1e+299,\"tooltip\":\"max inventory of feed "
      "material (kg)\",\"uilabel\":\"Maximum Feed Inventory\","
      "\"uitype\":\"range\",\"range\":[0.0,1e+299],\"doc\":\"maxim"
      "um total inventory of natural uranium in the "
      "enrichment facility (kg)\",\"type\":\"double\",\"index\":"
      "6,\"shape\":[-"
      "1],\"alias\":\"max_feed_inventory\"},\"max_enrich\":{\"de"
      "fault\":1.0,\"tooltip\":\"maximum allowed enrichment "
      "fraction\",\"doc\":\"maximum allowed weight fraction "
      "of U235 in product\",\"uilabel\":\"Maximum Allowed Enr"
      "ichment\",\"uitype\":\"range\",\"range\":[0.0,1.0],\"schem"
      "a\":\"<optional>          <element "
      "name=\\\"max_enrich\\\">              <data "
      "type=\\\"double\\\">                  <param "
      "name=\\\"minInclusive\\\">0</param>                  "
      "<param name=\\\"maxInclusive\\\">1</param>"
      "              </data>          </element>      </o"
      "ptional>\",\"type\":\"double\",\"index\":7,\"shape\":[-"
      "1],\"alias\":\"max_enrich\"},\"order_prefs\":{\"default\":"
      "1,\"userlevel\":10,\"tooltip\":\"Rank Material Requests"
      " by U235 Content\",\"uilabel\":\"Prefer feed with "
      "higher U235 content\",\"doc\":\"turn on preference "
      "ordering for input material so that EF chooses "
      "higher U235 content first\",\"type\":\"bool\",\"index\":8"
      ",\"shape\":[-"
      "1],\"alias\":\"order_prefs\"},\"swu_capacity\":{\"default"
      "\":1e+299,\"tooltip\":\"SWU capacity "
      "(kgSWU/timestep)\",\"uilabel\":\"SWU Capacity\",\"uitype"
      "\":\"range\",\"range\":[0.0,1e+299],\"doc\":\"separative "
      "work unit (SWU) capacity of enrichment facility "
      "(kgSWU/timestep) \",\"type\":\"double\",\"index\":9,\"shap"
      "e\":[-"
      "1],\"alias\":\"swu_capacity\"},\"inventory\":{\"capacity\""
      ":\"max_feed_inventory\",\"type\":[\"cyclus::toolkit::Re"
      "sBuf\",\"cyclus::Material\"],\"index\":10,\"shape\":[-1,-"
      "1]},\"tails\":{\"type\":[\"cyclus::toolkit::ResBuf\",\"cy"
      "clus::Material\"],\"index\":11,\"shape\":[-1,-"
      "1]},\"latitude\":{\"default\":0.0,\"uilabel\":\"Geographi"
      "cal 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\":12,\"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\":13,\"shape\":[-"
      "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"}},\"ni"
      "che\":\"enrichment facility\",\"doc\":\"The Enrichment "
      "facility is a simple agent that enriches natural "
      "uranium in a Cyclus simulation. It does not "
      "explicitly compute the physical enrichment "
      "process, rather it calculates the SWU required to "
      "convert a source uranium recipe (i.e. natural "
      "uranium) into a requested enriched recipe (i.e. 4%"
      " enriched uranium), given the natural uranium "
      "inventory constraint and its SWU capacity "
      "constraint.\\n\\nThe Enrichment facility requests an"
      " input commodity and associated recipe whose "
      "quantity is its remaining inventory capacity.  All"
      " facilities trading the same input commodity (even"
      " with different recipes) will offer materials for "
      "trade.  The Enrichment facility accepts any input "
      "materials with enrichments less than its tails "
      "assay, as long as some U235 is present, and "
      "preference increases with U235 content.  If no "
      "U235 is present in the offered material, the trade"
      " preference is set to -1 and the material is not "
      "accepted.  Any material components other than U235"
      " and U238 are sent directly to the tails "
      "buffer.\\n\\nThe Enrichment facility will bid on any"
      " request for its output commodity up to the "
      "maximum allowed enrichment (if not specified, "
      "default is 100%) It bids on either the request "
      "quantity, or the maximum quanity allowed by its "
      "SWU constraint or natural uranium inventory, "
      "whichever is lower. If multiple output commodities"
      " with different enrichment levels are requested "
      "and the facility does not have the SWU or quantity"
      " capacity to meet all requests, the requests are "
      "fully, then partially filled in unspecified but "
      "repeatable order. A request for the product "
      "commodity without an associated requested enriched"
      " recipe will not be fulfilled.\\n\\nAccumulated "
      "tails inventory is offered for trading as a "
      "specifiable output commodity.\"}", root);
    if (!parsed_ok) {
      throw cyclus::ValueError("failed to parse annotations for cycamore::Enrichment.");
    }
    return root;
  };
 
  virtual void InitInv(cyclus::Inventories& inv) {
    inventory.Push(inv["inventory"]);
        tails.Push(inv["tails"]);
    
  };
 
  virtual cyclus::Inventories SnapshotInv() {
    cyclus::Inventories invs;
    invs["inventory"] = inventory.PopNRes(inventory.count());
    inventory.Push(invs["inventory"]);
    invs["tails"] = tails.PopNRes(tails.count());
    tails.Push(invs["tails"]);
    return invs;
  };
 
  virtual void Snapshot(cyclus::DbInit di) {
    di.NewDatum("Info")
    ->AddVal("feed_commod", feed_commod, &cycpp_shape_feed_commod)
    ->AddVal("feed_recipe", feed_recipe, &cycpp_shape_feed_recipe)
    ->AddVal("product_commod", product_commod, &cycpp_shape_product_commod)
    ->AddVal("tails_commod", tails_commod, &cycpp_shape_tails_commod)
    ->AddVal("tails_assay", tails_assay, &cycpp_shape_tails_assay)
    ->AddVal("initial_feed", initial_feed, &cycpp_shape_initial_feed)
    ->AddVal("max_feed_inventory", max_feed_inventory, &cycpp_shape_max_feed_inventory)
    ->AddVal("max_enrich", max_enrich, &cycpp_shape_max_enrich)
    ->AddVal("order_prefs", order_prefs, &cycpp_shape_order_prefs)
    ->AddVal("swu_capacity", swu_capacity, &cycpp_shape_swu_capacity)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
#line 172 "/cycamore/src/enrichment.h"
 
  virtual std::string str();
  // ---
 
  // --- Facility Members ---
  virtual void Build(cyclus::Agent* parent);
  // ---
 
  // --- Agent Members ---
 
  virtual void Tick();
 
 
  virtual void Tock();
 
  virtual std::set<cyclus::RequestPortfolio<cyclus::Material>::Ptr>
      GetMatlRequests();
 
  virtual void AdjustMatlPrefs(cyclus::PrefMap<cyclus::Material>::type& prefs);
 
  virtual void AcceptMatlTrades(
      const std::vector< std::pair<cyclus::Trade<cyclus::Material>,
      cyclus::Material::Ptr> >& responses);
 
  virtual std::set<cyclus::BidPortfolio<cyclus::Material>::Ptr>
    GetMatlBids(cyclus::CommodMap<cyclus::Material>::type&
    commod_requests);
 
  virtual void GetMatlTrades(
    const std::vector< cyclus::Trade<cyclus::Material> >& trades,
    std::vector<std::pair<cyclus::Trade<cyclus::Material>,
    cyclus::Material::Ptr> >& responses);
  // ---
 
  bool ValidReq(const cyclus::Material::Ptr mat);
 
   inline void SetMaxInventorySize(double size) {
    max_feed_inventory = size;
    inventory.capacity(size);
  }
 
  inline void SwuCapacity(double capacity) {
    swu_capacity = capacity;
    current_swu_capacity = swu_capacity;
  }
 
  inline double SwuCapacity() const { return swu_capacity; }
 
  inline const cyclus::toolkit::ResBuf<cyclus::Material>& Tails() const {
    return tails;
  }
 
 private:
  void AddMat_(cyclus::Material::Ptr mat);
 
  cyclus::Material::Ptr Request_();
 
  cyclus::Material::Ptr Offer_(cyclus::Material::Ptr req);
 
  cyclus::Material::Ptr Enrich_(cyclus::Material::Ptr mat, double qty);
 
  double FeedAssay();
 
  void RecordEnrichment_(double natural_u, double swu);
 
  void RecordPosition();
 
  #pragma cyclus var {     "tooltip": "feed commodity",                                     "doc": "feed commodity that the enrichment facility accepts",           "uilabel": "Feed Commodity",                                        "uitype": "incommodity"   }
#line 285 "/cycamore/src/enrichment.h"
  std::string feed_commod;
  std::vector<int> cycpp_shape_feed_commod;
#line 286 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {     "tooltip": "feed recipe",                                                "doc": "recipe for enrichment facility feed commodity",                 "uilabel": "Feed Recipe",                                       "uitype": "inrecipe"   }
#line 293 "/cycamore/src/enrichment.h"
  std::string feed_recipe;
  std::vector<int> cycpp_shape_feed_recipe;
#line 294 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {     "tooltip": "product commodity",                                          "doc": "product commodity that the enrichment facility generates",       "uilabel": "Product Commodity",                                         "uitype": "outcommodity"   }
#line 301 "/cycamore/src/enrichment.h"
  std::string product_commod;
  std::vector<int> cycpp_shape_product_commod;
#line 302 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {                                                      "tooltip": "tails commodity",                                           "doc": "tails commodity supplied by enrichment facility",               "uilabel": "Tails Commodity",                                       "uitype": "outcommodity"   }
#line 309 "/cycamore/src/enrichment.h"
  std::string tails_commod;
  std::vector<int> cycpp_shape_tails_commod;
#line 310 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {                                                      "default": 0.003, "tooltip": "tails assay",                             "uilabel": "Tails Assay",                                 "uitype": "range",                                   "range": [0.0, 0.003],                                  "doc": "tails assay from the enrichment process",         }
#line 318 "/cycamore/src/enrichment.h"
  double tails_assay;
  std::vector<int> cycpp_shape_tails_assay;
#line 319 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {                                                      "default": 0, "tooltip": "initial uranium reserves (kg)",               "uilabel": "Initial Feed Inventory",                                    "doc": "amount of natural uranium stored at the enrichment "            "facility at the beginning of the simulation (kg)"                    }
#line 326 "/cycamore/src/enrichment.h"
  double initial_feed;
  std::vector<int> cycpp_shape_initial_feed;
#line 327 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {                                                      "default": CY_LARGE_DOUBLE, "tooltip": "max inventory of feed material (kg)",     "uilabel": "Maximum Feed Inventory",     "uitype": "range",     "range": [0.0, CY_LARGE_DOUBLE],     "doc": "maximum total inventory of natural uranium in "                         "the enrichment facility (kg)"       }
#line 336 "/cycamore/src/enrichment.h"
  double max_feed_inventory;
  std::vector<int> cycpp_shape_max_feed_inventory;
#line 337 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {     "default": 1.0,                                                  "tooltip": "maximum allowed enrichment fraction",               "doc": "maximum allowed weight fraction of U235 in product",     "uilabel": "Maximum Allowed Enrichment",     "uitype": "range",     "range": [0.0,1.0],     "schema": '<optional>'                                            '          <element name="max_enrich">'                                 '              <data type="double">'                            '                  <param name="minInclusive">0</param>'           '                  <param name="maxInclusive">1</param>'           '              </data>'                                                   '          </element>'                                                  '      </optional>'                                       }
#line 354 "/cycamore/src/enrichment.h"
  double max_enrich;
  std::vector<int> cycpp_shape_max_enrich;
#line 355 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {     "default": 1,                           "userlevel": 10,                                                         "tooltip": "Rank Material Requests by U235 Content",                    "uilabel": "Prefer feed with higher U235 content",     "doc": "turn on preference ordering for input material "                        "so that EF chooses higher U235 content first"   }
#line 364 "/cycamore/src/enrichment.h"
  bool order_prefs;
  std::vector<int> cycpp_shape_order_prefs;
#line 365 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {                                                     "default": CY_LARGE_DOUBLE,                                                     "tooltip": "SWU capacity (kgSWU/timestep)",                             "uilabel": "SWU Capacity",                                             "uitype": "range",                                                      "range": [0.0, CY_LARGE_DOUBLE],                                                   "doc": "separative work unit (SWU) capacity of enrichment "                           "facility (kgSWU/timestep) "                                       }
#line 375 "/cycamore/src/enrichment.h"
  double swu_capacity;
  std::vector<int> cycpp_shape_swu_capacity;
 
#line 376 "/cycamore/src/enrichment.h"
 
  double current_swu_capacity;
 
  #pragma cyclus var { 'capacity': 'max_feed_inventory' }
  cyclus::toolkit::ResBuf<cyclus::Material> inventory;
  std::vector<int> cycpp_shape_inventory;
  // natural u
#line 381 "/cycamore/src/enrichment.h"
  #pragma cyclus var {}
  cyclus::toolkit::ResBuf<cyclus::Material> tails;
  std::vector<int> cycpp_shape_tails;
  // depleted u
#line 383 "/cycamore/src/enrichment.h"
 
  // used to total intra-timestep swu and natu usage for meeting requests -
  // these help enable time series generation.
  double intra_timestep_swu_;
  double intra_timestep_feed_;
 
  friend class EnrichmentTest;
  // ---
 
  #pragma cyclus var {     "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."   }
#line 398 "/cycamore/src/enrichment.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 399 "/cycamore/src/enrichment.h"
 
 
  #pragma cyclus var {     "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."   }
#line 406 "/cycamore/src/enrichment.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
 
#line 407 "/cycamore/src/enrichment.h"
 
  cyclus::toolkit::Position coordinates;
};
 
}  // namespace cycamore
 
#endif // CYCAMORE_SRC_ENRICHMENT_FACILITY_H_