build/cycamore/separations.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/separations.h"
#ifndef CYCAMORE_SRC_SEPARATIONS_H_
#define CYCAMORE_SRC_SEPARATIONS_H_
 
#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 {

cyclus::Material::Ptr SepMaterial(std::map<int, double> effs,
                                  cyclus::Material::Ptr mat);

class Separations
  : public cyclus::Facility,
    public cyclus::toolkit::Position {
#pragma cyclus note {   "niche": "separations",   "doc":     "Separations processes feed material into one or more streams containing"     " specific elements and/or nuclides.  It uses mass-based efficiencies."     "\n\n"     "User defined separations streams are specified as groups of"     " component-efficiency pairs where 'component' means either a particular"     " element or a particular nuclide.  Each component's paired efficiency"     " represents the mass fraction of that component in the feed that is"     " separated into that stream.  The efficiencies of a particular component"     " across all streams must sum up to less than or equal to one.  If less than"     " one, the remainining material is sent to a waste inventory and"     " (potentially) traded away from there."     "\n\n"     "The facility receives material into a feed inventory that it processes with"     " a specified throughput each time step.  Each output stream has a"     " corresponding output inventory size/limit.  If the facility is unable to"     " reduce its stocks by trading and hits this limit for any of its output"     " streams, further processing/separations of feed material will halt until"     " room is again available in the output streams."     "", }
#line 65 "/cycamore/src/separations.h"
 public:
  Separations(cyclus::Context* ctx);
  virtual ~Separations(){};
 
  virtual std::string version() { return CYCAMORE_VERSION; }
 
  virtual void Tick();
  virtual void Tock();
  virtual void EnterNotify();
 
  virtual void AcceptMatlTrades(const std::vector<std::pair<
      cyclus::Trade<cyclus::Material>, cyclus::Material::Ptr> >& responses);
 
  virtual std::set<cyclus::RequestPortfolio<cyclus::Material>::Ptr>
  GetMatlRequests();
 
  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);
 
  virtual bool CheckDecommissionCondition();
  virtual cyclus::Agent* Clone() {
    cycamore::Separations* m = new cycamore::Separations(context());
    m->InitFrom(this);
    return m;
  };
#line 90 "/cycamore/src/separations.h"
 
  virtual void InitFrom(cycamore::Separations* 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_feed_commods[2] = {-1, -1};
    cycpp_shape_feed_commods = std::vector<int>(rawcycpp_shape_feed_commods, rawcycpp_shape_feed_commods + 2);
    int rawcycpp_shape_feed_commod_prefs[2] = {-1, -1};
    cycpp_shape_feed_commod_prefs = std::vector<int>(rawcycpp_shape_feed_commod_prefs, rawcycpp_shape_feed_commod_prefs + 2);
    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_feedbuf_size[1] = {-1};
    cycpp_shape_feedbuf_size = std::vector<int>(rawcycpp_shape_feedbuf_size, rawcycpp_shape_feedbuf_size + 1);
    int rawcycpp_shape_feed[2] = {-1, -1};
    cycpp_shape_feed = std::vector<int>(rawcycpp_shape_feed, rawcycpp_shape_feed + 2);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_leftover_commod[1] = {-1};
    cycpp_shape_leftover_commod = std::vector<int>(rawcycpp_shape_leftover_commod, rawcycpp_shape_leftover_commod + 1);
    int rawcycpp_shape_leftoverbuf_size[1] = {-1};
    cycpp_shape_leftoverbuf_size = std::vector<int>(rawcycpp_shape_leftoverbuf_size, rawcycpp_shape_leftoverbuf_size + 1);
    int rawcycpp_shape_leftover[2] = {-1, -1};
    cycpp_shape_leftover = std::vector<int>(rawcycpp_shape_leftover, rawcycpp_shape_leftover + 2);
    int rawcycpp_shape_streams_[7] = {-1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_streams_ = std::vector<int>(rawcycpp_shape_streams_, rawcycpp_shape_streams_ + 7);
    latitude = m->latitude;
    longitude = m->longitude;
    feed_commods = m->feed_commods;
    feed_commod_prefs = m->feed_commod_prefs;
    feed_recipe = m->feed_recipe;
    feedbuf_size = m->feedbuf_size;
    throughput = m->throughput;
    leftover_commod = m->leftover_commod;
    leftoverbuf_size = m->leftoverbuf_size;
    streams_ = m->streams_;
    feed.capacity(m->feed.capacity());
    leftover.capacity(m->leftover.capacity());
  };
 
  virtual void 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_feed_commods[2] = {-1, -1};
    cycpp_shape_feed_commods = std::vector<int>(rawcycpp_shape_feed_commods, rawcycpp_shape_feed_commods + 2);
    int rawcycpp_shape_feed_commod_prefs[2] = {-1, -1};
    cycpp_shape_feed_commod_prefs = std::vector<int>(rawcycpp_shape_feed_commod_prefs, rawcycpp_shape_feed_commod_prefs + 2);
    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_feedbuf_size[1] = {-1};
    cycpp_shape_feedbuf_size = std::vector<int>(rawcycpp_shape_feedbuf_size, rawcycpp_shape_feedbuf_size + 1);
    int rawcycpp_shape_feed[2] = {-1, -1};
    cycpp_shape_feed = std::vector<int>(rawcycpp_shape_feed, rawcycpp_shape_feed + 2);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_leftover_commod[1] = {-1};
    cycpp_shape_leftover_commod = std::vector<int>(rawcycpp_shape_leftover_commod, rawcycpp_shape_leftover_commod + 1);
    int rawcycpp_shape_leftoverbuf_size[1] = {-1};
    cycpp_shape_leftoverbuf_size = std::vector<int>(rawcycpp_shape_leftoverbuf_size, rawcycpp_shape_leftoverbuf_size + 1);
    int rawcycpp_shape_leftover[2] = {-1, -1};
    cycpp_shape_leftover = std::vector<int>(rawcycpp_shape_leftover, rawcycpp_shape_leftover + 2);
    int rawcycpp_shape_streams_[7] = {-1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_streams_ = std::vector<int>(rawcycpp_shape_streams_, rawcycpp_shape_streams_ + 7);
    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("feed_commods", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("val");
      std::vector< std::string > feed_commods_val;
      feed_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;
        }
        feed_commods_val[i1] = elem;
      }
      feed_commods = feed_commods_val;
    }
    if (sub->NMatches("feed_commod_prefs") > 0) {
      {
        cyclus::InfileTree* bub = sub->SubTree("feed_commod_prefs", 0);
        cyclus::InfileTree* sub = bub;
        int n1 = sub->NMatches("val");
        std::vector< double > feed_commod_prefs_val;
        feed_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;
          }
          feed_commod_prefs_val[i1] = elem;
        }
        feed_commod_prefs = feed_commod_prefs_val;
      }
    } else {
      std::vector< double > feed_commod_prefs_tmp;
      feed_commod_prefs_tmp.resize(0);
      {
      }
      feed_commod_prefs = feed_commod_prefs_tmp;
    }
    if (sub->NMatches("feed_recipe") > 0) {
      {
        std::string feed_recipe_val = cyclus::Query<std::string>(sub, "feed_recipe");
        feed_recipe = feed_recipe_val;
      }
    } else {
      std::string feed_recipe_tmp("");
      feed_recipe = feed_recipe_tmp;
    }
    {
      double feedbuf_size_val = cyclus::Query<double>(sub, "feedbuf_size");
      feedbuf_size = feedbuf_size_val;
    }
    if (sub->NMatches("throughput") > 0) {
      {
        double throughput_val = cyclus::Query<double>(sub, "throughput");
        throughput = throughput_val;
      }
    } else {
      double throughput_tmp = 1e+299;
      throughput = throughput_tmp;
    }
    if (sub->NMatches("leftover_commod") > 0) {
      {
        std::string leftover_commod_val = cyclus::Query<std::string>(sub, "leftover_commod");
        leftover_commod = leftover_commod_val;
      }
    } else {
      std::string leftover_commod_tmp("default-waste-stream");
      leftover_commod = leftover_commod_tmp;
    }
    if (sub->NMatches("leftoverbuf_size") > 0) {
      {
        double leftoverbuf_size_val = cyclus::Query<double>(sub, "leftoverbuf_size");
        leftoverbuf_size = leftoverbuf_size_val;
      }
    } else {
      double leftoverbuf_size_tmp = 1e+299;
      leftoverbuf_size = leftoverbuf_size_tmp;
    }
    {
      cyclus::InfileTree* bub = sub->SubTree("streams", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("item");
      std::map< std::string, std::pair< double, std::map< int, double > > > streams__val;
      for (int i1 = 0; i1 < n1; ++i1) {
        std::string key;
        {
          std::string key_in = cyclus::Query<std::string>(sub, "item/commod", i1);
          key = key_in;
        }
        std::pair< double, std::map< int, double > > val;
        {
          cyclus::InfileTree* bub = sub->SubTree("item/info", i1);
          cyclus::InfileTree* sub = bub;
            double firsti1;
            {
              double firsti1_in = cyclus::Query<double>(sub, "buf_size", 0);
              firsti1 = firsti1_in;
            }
            std::map< int, double > secondi1;
            {
              cyclus::InfileTree* bub = sub->SubTree("efficiencies", 0);
              cyclus::InfileTree* sub = bub;
              int n2 = sub->NMatches("item");
              std::map< int, double > secondi1_in;
              for (int i2 = 0; i2 < n2; ++i2) {
                int key;
                {
                  int key_in = pyne::nucname::id(cyclus::Query<std::string>(sub, "item/comp", i2));
                  key = key_in;
                }
                double val;
                {
                  double val_in = cyclus::Query<double>(sub, "item/eff", i2);
                  val = val_in;
                }
                secondi1_in[key] = val;
              }
              secondi1 = secondi1_in;
            }
          std::pair< double, std::map< int, double > > val_in(firsti1, secondi1);
          val = val_in;
        }
        streams__val[key] = val;
      }
      streams_ = streams__val;
    }
    di.NewDatum("Info")
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->AddVal("feed_commods", feed_commods, &cycpp_shape_feed_commods)
    ->AddVal("feed_commod_prefs", feed_commod_prefs, &cycpp_shape_feed_commod_prefs)
    ->AddVal("feed_recipe", feed_recipe, &cycpp_shape_feed_recipe)
    ->AddVal("feedbuf_size", feedbuf_size, &cycpp_shape_feedbuf_size)
    ->AddVal("throughput", throughput, &cycpp_shape_throughput)
    ->AddVal("leftover_commod", leftover_commod, &cycpp_shape_leftover_commod)
    ->AddVal("leftoverbuf_size", leftoverbuf_size, &cycpp_shape_leftoverbuf_size)
    ->AddVal("streams_", streams_, &cycpp_shape_streams_)
    ->Record();
  };
 
  virtual void 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_feed_commods[2] = {-1, -1};
    cycpp_shape_feed_commods = std::vector<int>(rawcycpp_shape_feed_commods, rawcycpp_shape_feed_commods + 2);
    int rawcycpp_shape_feed_commod_prefs[2] = {-1, -1};
    cycpp_shape_feed_commod_prefs = std::vector<int>(rawcycpp_shape_feed_commod_prefs, rawcycpp_shape_feed_commod_prefs + 2);
    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_feedbuf_size[1] = {-1};
    cycpp_shape_feedbuf_size = std::vector<int>(rawcycpp_shape_feedbuf_size, rawcycpp_shape_feedbuf_size + 1);
    int rawcycpp_shape_feed[2] = {-1, -1};
    cycpp_shape_feed = std::vector<int>(rawcycpp_shape_feed, rawcycpp_shape_feed + 2);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_leftover_commod[1] = {-1};
    cycpp_shape_leftover_commod = std::vector<int>(rawcycpp_shape_leftover_commod, rawcycpp_shape_leftover_commod + 1);
    int rawcycpp_shape_leftoverbuf_size[1] = {-1};
    cycpp_shape_leftoverbuf_size = std::vector<int>(rawcycpp_shape_leftoverbuf_size, rawcycpp_shape_leftoverbuf_size + 1);
    int rawcycpp_shape_leftover[2] = {-1, -1};
    cycpp_shape_leftover = std::vector<int>(rawcycpp_shape_leftover, rawcycpp_shape_leftover + 2);
    int rawcycpp_shape_streams_[7] = {-1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_streams_ = std::vector<int>(rawcycpp_shape_streams_, rawcycpp_shape_streams_ + 7);
    cyclus::QueryResult qr = b->Query("Info", NULL);
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
    feed_commods = qr.GetVal<std::vector< std::string > >("feed_commods");
    feed_commod_prefs = qr.GetVal<std::vector< double > >("feed_commod_prefs");
    feed_recipe = qr.GetVal<std::string>("feed_recipe");
    feedbuf_size = qr.GetVal<double>("feedbuf_size");
    throughput = qr.GetVal<double>("throughput");
    leftover_commod = qr.GetVal<std::string>("leftover_commod");
    leftoverbuf_size = qr.GetVal<double>("leftoverbuf_size");
    streams_ = qr.GetVal<std::map< std::string, std::pair< double, std::map< int, double > > > >("streams_");
    feed.capacity(feedbuf_size);
    leftover.capacity(leftoverbuf_size);
  };
 
  virtual std::string 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=\"feed_commods\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"val\">\n"
      "                <data type=\"string\"/>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"feed_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=\"feed_recipe\">\n"
      "            <a:documentation>Name for recipe to be used in feed requests. Empty string results in use of a dummy recipe.</a:documentation>\n"
      "            <data type=\"string\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <element name=\"feedbuf_size\">\n"
      "        <a:documentation>Maximum amount of feed material to keep on hand.</a:documentation>\n"
      "        <data type=\"double\"/>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"throughput\">\n"
      "            <a:documentation>Maximum quantity of feed material that can be processed per time step.</a:documentation>\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"leftover_commod\">\n"
      "            <a:documentation>Commodity on which to trade the leftover separated material stream. This MUST NOT be the same as any commodity used to define the other separations streams.</a:documentation>\n"
      "            <data type=\"string\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"leftoverbuf_size\">\n"
      "            <a:documentation>Maximum amount of leftover separated material (not included in any other stream) that can be stored. If full, the facility halts operation until space becomes available.</a:documentation>\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <element name=\"streams\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"item\">\n"
      "                <interleave>\n"
      "                    <element name=\"commod\">\n"
      "                        <data type=\"string\"/>\n"
      "                    </element>\n"
      "                    <element name=\"info\">\n"
      "                        <interleave>\n"
      "                            <element name=\"buf_size\">\n"
      "                                <data type=\"double\"/>\n"
      "                            </element>\n"
      "                            <element name=\"efficiencies\">\n"
      "                                <oneOrMore>\n"
      "                                    <element name=\"item\">\n"
      "                                        <interleave>\n"
      "                                            <element name=\"comp\">\n"
      "                                                <data type=\"string\"/>\n"
      "                                            </element>\n"
      "                                            <element name=\"eff\">\n"
      "                                                <data type=\"double\"/>\n"
      "                                            </element>\n"
      "                                        </interleave>\n"
      "                                    </element>\n"
      "                                </oneOrMore>\n"
      "                            </element>\n"
      "                        </interleave>\n"
      "                    </element>\n"
      "                </interleave>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\n"
      "</interleave>\n";
  };
 
  virtual Json::Value annotations() {
    Json::Value root;
    Json::Reader reader;
    bool parsed_ok = reader.parse(
      "{\"name\":\"cycamore::Separations\",\"entity\":\"facility"
      "\",\"parents\":[\"cyclus::Facility\",\"cyclus::toolkit::"
      "Position\"],\"all_parents\":[\"EconomicEntity\",\"cyclus"
      "::Agent\",\"cyclus::Facility\",\"cyclus::Ider\",\"cyclus"
      "::StateWrangler\",\"cyclus::TimeListener\",\"cyclus::T"
      "rader\",\"cyclus::toolkit::Position\"],\"vars\":{\"latit"
      "ude\":{\"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\"},\"fee"
      "d_commods\":{\"doc\":\"Ordered list of commodities on "
      "which to request feed material to separate. Order "
      "only matters for matching up with feed commodity "
      "preferences if specified.\",\"uilabel\":[\"Feed "
      "Commodity List\",\"\"],\"uitype\":[\"oneormore\",\"incommo"
      "dity\"],\"type\":[\"std::vector\",\"std::string\"],\"index"
      "\":2,\"shape\":[-1,-"
      "1],\"alias\":[\"feed_commods\",\"val\"],\"tooltip\":[\"feed"
      "_commods\",\"\"]},\"feed_commod_prefs\":{\"default\":[],\""
      "uilabel\":[\"Feed Commodity Preference "
      "List\",\"\"],\"doc\":\"Feed commodity request "
      "preferences for each of the given feed commodities"
      " (same order). If unspecified, default is to use "
      "1.0 for all preferences.\",\"type\":[\"std::vector\",\"d"
      "ouble\"],\"index\":3,\"shape\":[-1,-"
      "1],\"alias\":[\"feed_commod_prefs\",\"val\"],\"tooltip\":["
      "\"feed_commod_prefs\",\"\"]},\"feed_recipe\":{\"doc\":\"Nam"
      "e for recipe to be used in feed requests. Empty "
      "string results in use of a dummy "
      "recipe.\",\"uilabel\":\"Feed Commodity Recipe List\",\"u"
      "itype\":\"inrecipe\",\"default\":\"\",\"type\":\"std::string"
      "\",\"index\":4,\"shape\":[-"
      "1],\"alias\":\"feed_recipe\",\"tooltip\":\"feed_recipe\"},"
      "\"feedbuf_size\":{\"doc\":\"Maximum amount of feed "
      "material to keep on hand.\",\"uilabel\":\"Maximum Feed"
      " Inventory\",\"units\":\"kg\",\"type\":\"double\",\"index\":5"
      ",\"shape\":[-"
      "1],\"alias\":\"feedbuf_size\",\"tooltip\":\"feedbuf_size\""
      "},\"feed\":{\"capacity\":\"feedbuf_size\",\"type\":[\"cyclu"
      "s::toolkit::ResBuf\",\"cyclus::Material\"],\"index\":6,"
      "\"shape\":[-1,-1]},\"throughput\":{\"doc\":\"Maximum "
      "quantity of feed material that can be processed "
      "per time step.\",\"uilabel\":\"Maximum Separations Thr"
      "oughput\",\"default\":1e+299,\"uitype\":\"range\",\"range\""
      ":[0.0,1e+299],\"units\":\"kg/(time step)\",\"type\":\"dou"
      "ble\",\"index\":7,\"shape\":[-"
      "1],\"alias\":\"throughput\",\"tooltip\":\"throughput\"},\"l"
      "eftover_commod\":{\"doc\":\"Commodity on which to "
      "trade the leftover separated material stream. This"
      " MUST NOT be the same as any commodity used to "
      "define the other separations streams.\",\"uitype\":\"o"
      "utcommodity\",\"uilabel\":\"Leftover "
      "Commodity\",\"default\":\"default-waste-stream\",\"type\""
      ":\"std::string\",\"index\":8,\"shape\":[-"
      "1],\"alias\":\"leftover_commod\",\"tooltip\":\"leftover_c"
      "ommod\"},\"leftoverbuf_size\":{\"doc\":\"Maximum amount "
      "of leftover separated material (not included in "
      "any other stream) that can be stored. If full, the"
      " facility halts operation until space becomes "
      "available.\",\"uilabel\":\"Maximum Leftover Inventory\""
      ",\"default\":1e+299,\"uitype\":\"range\",\"range\":[0.0,1e"
      "+299],\"units\":\"kg\",\"type\":\"double\",\"index\":9,\"shap"
      "e\":[-"
      "1],\"alias\":\"leftoverbuf_size\",\"tooltip\":\"leftoverb"
      "uf_size\"},\"leftover\":{\"capacity\":\"leftoverbuf_size"
      "\",\"type\":[\"cyclus::toolkit::ResBuf\",\"cyclus::Mater"
      "ial\"],\"index\":10,\"shape\":[-1,-"
      "1]},\"streams_\":{\"alias\":[[\"streams\",\"item\"],\"commo"
      "d\",[\"info\",\"buf_size\",[[\"efficiencies\",\"item\"],\"co"
      "mp\",\"eff\"]]],\"uitype\":[\"oneormore\",\"outcommodity\","
      "[\"pair\",\"double\",[\"oneormore\",\"nuclide\",\"double\"]]"
      "],\"uilabel\":[[\"Separations Streams and Efficiencie"
      "s\",\"\"],\"\",[\"\",\"\",[[\"\",\"\"],\"\",\"\"]]],\"doc\":\"Output "
      "streams for separations. Each stream must have a "
      "unique name identifying the commodity on  which "
      "its material is traded, a max buffer capacity in "
      "kg (neg values indicate infinite size), and a set "
      "of component efficiencies. 'comp' is a component "
      "to be separated into the stream (e.g. U, Pu, etc.)"
      " and 'eff' is the mass fraction of the component "
      "that is separated from the feed into this output "
      "stream. If any stream buffer is full, the facility"
      " halts operation until space becomes available. "
      "The sum total of all component efficiencies across"
      " streams must be less than or equal to 1 (e.g. sum"
      " of U efficiencies for all streams must be <= 1).\""
      ",\"type\":[\"std::map\",\"std::string\",[\"std::pair\",\"do"
      "uble\",[\"std::map\",\"int\",\"double\"]]],\"index\":11,\"sh"
      "ape\":[-1,-1,-1,-1,-1,-1,-"
      "1],\"tooltip\":[[\"streams_\",\"\"],\"\",[\"\",\"\",[[\"\",\"\"],\""
      "\",\"\"]]]},\"streams\":\"streams_\"},\"niche\":\"separation"
      "s\",\"doc\":\"Separations processes feed material into"
      " one or more streams containing specific elements "
      "and/or nuclides.  It uses mass-based "
      "efficiencies.\\n\\nUser defined separations streams "
      "are specified as groups of component-efficiency "
      "pairs where 'component' means either a particular "
      "element or a particular nuclide.  Each component's"
      " paired efficiency represents the mass fraction of"
      " that component in the feed that is separated into"
      " that stream.  The efficiencies of a particular "
      "component across all streams must sum up to less "
      "than or equal to one.  If less than one, the "
      "remainining material is sent to a waste inventory "
      "and (potentially) traded away from there.\\n\\nThe "
      "facility receives material into a feed inventory "
      "that it processes with a specified throughput each"
      " time step.  Each output stream has a "
      "corresponding output inventory size/limit.  If the"
      " facility is unable to reduce its stocks by "
      "trading and hits this limit for any of its output "
      "streams, further processing/separations of feed "
      "material will halt until room is again available "
      "in the output streams.\"}", root);
    if (!parsed_ok) {
      throw cyclus::ValueError("failed to parse annotations for cycamore::Separations.");
    }
    return root;
  };
 
  virtual void Snapshot(cyclus::DbInit di) {
    di.NewDatum("Info")
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->AddVal("feed_commods", feed_commods, &cycpp_shape_feed_commods)
    ->AddVal("feed_commod_prefs", feed_commod_prefs, &cycpp_shape_feed_commod_prefs)
    ->AddVal("feed_recipe", feed_recipe, &cycpp_shape_feed_recipe)
    ->AddVal("feedbuf_size", feedbuf_size, &cycpp_shape_feedbuf_size)
    ->AddVal("throughput", throughput, &cycpp_shape_throughput)
    ->AddVal("leftover_commod", leftover_commod, &cycpp_shape_leftover_commod)
    ->AddVal("leftoverbuf_size", leftoverbuf_size, &cycpp_shape_leftoverbuf_size)
    ->AddVal("streams_", streams_, &cycpp_shape_streams_)
    ->Record();
  };
#line 98 "/cycamore/src/separations.h"
  // the following pragmas are ommitted and the functions are written
  // manually in order to handle the vector of resource buffers:
  //
  //     #pragma cyclus snapshotinv
  //     #pragma cyclus initinv
 
  virtual cyclus::Inventories SnapshotInv();
  virtual void InitInv(cyclus::Inventories& inv);
 
 private:
 // Code Injection:
 #include "toolkit/position.cycpp.h"
 
  #pragma cyclus var {     "doc": "Ordered list of commodities on which to request feed material to "            "separate. Order only matters for matching up with feed commodity "            "preferences if specified.",     "uilabel": "Feed Commodity List",     "uitype": ["oneormore", "incommodity"],   }
#line 118 "/cycamore/src/separations.h"
  std::vector<std::string> feed_commods;
  std::vector<int> cycpp_shape_feed_commods;
#line 119 "/cycamore/src/separations.h"
 
 
  #pragma cyclus var {     "default": [],     "uilabel": "Feed Commodity Preference List",     "doc": "Feed commodity request preferences for each of the given feed "            "commodities (same order)."            " If unspecified, default is to use 1.0 for all "           "preferences.",                                                       }
#line 128 "/cycamore/src/separations.h"
  std::vector<double> feed_commod_prefs;
  std::vector<int> cycpp_shape_feed_commod_prefs;
#line 129 "/cycamore/src/separations.h"
 
 
  #pragma cyclus var {     "doc": "Name for recipe to be used in feed requests."            " Empty string results in use of a dummy recipe.",     "uilabel": "Feed Commodity Recipe List",     "uitype": "inrecipe",     "default": "",   }
#line 137 "/cycamore/src/separations.h"
  std::string feed_recipe;
  std::vector<int> cycpp_shape_feed_recipe;
#line 138 "/cycamore/src/separations.h"
 
 
  #pragma cyclus var {     "doc" : "Maximum amount of feed material to keep on hand.",     "uilabel": "Maximum Feed Inventory",                         "units" : "kg",   }
#line 144 "/cycamore/src/separations.h"
  double feedbuf_size;
  std::vector<int> cycpp_shape_feedbuf_size;
#line 145 "/cycamore/src/separations.h"
 
 
  #pragma cyclus var {     "capacity" : "feedbuf_size",   }
#line 149 "/cycamore/src/separations.h"
  cyclus::toolkit::ResBuf<cyclus::Material> feed;
  std::vector<int> cycpp_shape_feed;
#line 150 "/cycamore/src/separations.h"
 
 
  #pragma cyclus var {     "doc" : "Maximum quantity of feed material that can be processed per time "            "step.",     "uilabel": "Maximum Separations Throughput",     "default": CY_LARGE_DOUBLE,     "uitype": "range",     "range": [0.0, CY_LARGE_DOUBLE],     "units": "kg/(time step)",   }
#line 160 "/cycamore/src/separations.h"
  double throughput;
  std::vector<int> cycpp_shape_throughput;
#line 161 "/cycamore/src/separations.h"
 
 
  #pragma cyclus var {     "doc": "Commodity on which to trade the leftover separated material "            "stream. This MUST NOT be the same as any commodity used to define "           "the other separations streams.",     "uitype": "outcommodity",     "uilabel": "Leftover Commodity",     "default": "default-waste-stream",   }
#line 170 "/cycamore/src/separations.h"
  std::string leftover_commod;
  std::vector<int> cycpp_shape_leftover_commod;
#line 171 "/cycamore/src/separations.h"
 
 
  #pragma cyclus var {     "doc" : "Maximum amount of leftover separated material (not included in"             " any other stream) that can be stored."             " If full, the facility halts operation until space becomes "             "available.",     "uilabel": "Maximum Leftover Inventory",     "default": CY_LARGE_DOUBLE,     "uitype": "range",     "range": [0.0, CY_LARGE_DOUBLE],     "units": "kg",   }
#line 183 "/cycamore/src/separations.h"
  double leftoverbuf_size;
  std::vector<int> cycpp_shape_leftoverbuf_size;
#line 184 "/cycamore/src/separations.h"
 
 
 #pragma cyclus var {     "capacity" : "leftoverbuf_size",   }
#line 188 "/cycamore/src/separations.h"
  cyclus::toolkit::ResBuf<cyclus::Material> leftover;
  std::vector<int> cycpp_shape_leftover;
#line 189 "/cycamore/src/separations.h"
 
 
  #pragma cyclus var {     "alias": ["streams", "commod", ["info", "buf_size", ["efficiencies", "comp", "eff"]]],     "uitype": ["oneormore", "outcommodity", ["pair", "double", ["oneormore", "nuclide", "double"]]],     "uilabel": "Separations Streams and Efficiencies",     "doc": "Output streams for separations."            " Each stream must have a unique name identifying the commodity on "           " which its material is traded,"            " a max buffer capacity in kg (neg values indicate infinite size),"            " and a set of component efficiencies."            " 'comp' is a component to be separated into the stream"            " (e.g. U, Pu, etc.) and 'eff' is the mass fraction of the"            " component that is separated from the feed into this output"            " stream. If any stream buffer is full, the facility halts"            " operation until space becomes available."            " The sum total of all component efficiencies across streams must"            " be less than or equal to 1"            " (e.g. sum of U efficiencies for all streams must be <= 1).",   }
#line 208 "/cycamore/src/separations.h"
  std::map<std::string, std::pair<double, std::map<int, double> > > streams_;
  std::vector<int> cycpp_shape_streams_;
 
#line 209 "/cycamore/src/separations.h"
 
  // custom SnapshotInv and InitInv and EnterNotify are used to persist this
  // state var.
  std::map<std::string, cyclus::toolkit::ResBuf<cyclus::Material> > streambufs;
 
  void Record(std::string name, double val, std::string type);
};
 
}  // namespace cycamore
 
#endif  // CYCAMORE_SRC_SEPARATIONS_H_