build/cycamore/mixer.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/mixer.h"
#ifndef CYCAMORE_SRC_MIXER_H_
#define CYCAMORE_SRC_MIXER_H_
 
#include <string>
#include "cycamore_version.h"
#include "cyclus.h"
 
#pragma cyclus exec from cyclus.system import CY_LARGE_DOUBLE, CY_LARGE_INT, CY_NEAR_ZERO
 
namespace cycamore {
 
class Mixer
  : public cyclus::Facility,
    public cyclus::toolkit::Position {
#pragma cyclus note {                 "niche": "mixing facility",                                     "doc": "Mixer mixes N streams with fixed, static, user-specified"            " ratios into a single output stream. The Mixer has N input"           " inventories: one for each streams to be mixed, and one output"           " stream. The supplying of mixed material is constrained by "           " available inventory of mixed material quantities.",     }
#line 28 "/cycamore/src/mixer.h"
 
  friend class MixerTest;
 
 public:
  Mixer(cyclus::Context* ctx);
  virtual ~Mixer(){};
 
  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 cyclus::Agent* Clone() {
    cycamore::Mixer* m = new cycamore::Mixer(context());
    m->InitFrom(this);
    return m;
  };
#line 45 "/cycamore/src/mixer.h"
 
  virtual void InitFrom(cycamore::Mixer* m) {
    cyclus::Facility::InitFrom(m);
    int rawcycpp_shape_streams_[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_streams_ = std::vector<int>(rawcycpp_shape_streams_, rawcycpp_shape_streams_ + 8);
    int rawcycpp_shape_out_commod[1] = {-1};
    cycpp_shape_out_commod = std::vector<int>(rawcycpp_shape_out_commod, rawcycpp_shape_out_commod + 1);
    int rawcycpp_shape_out_buf_size[1] = {-1};
    cycpp_shape_out_buf_size = std::vector<int>(rawcycpp_shape_out_buf_size, rawcycpp_shape_out_buf_size + 1);
    int rawcycpp_shape_output[2] = {-1, -1};
    cycpp_shape_output = std::vector<int>(rawcycpp_shape_output, rawcycpp_shape_output + 2);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 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);
    streams_ = m->streams_;
    out_commod = m->out_commod;
    out_buf_size = m->out_buf_size;
    throughput = m->throughput;
    latitude = m->latitude;
    longitude = m->longitude;
    output.capacity(m->output.capacity());
  };
 
  virtual void InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
    cyclus::Facility::InfileToDb(tree, di);
    int rawcycpp_shape_streams_[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_streams_ = std::vector<int>(rawcycpp_shape_streams_, rawcycpp_shape_streams_ + 8);
    int rawcycpp_shape_out_commod[1] = {-1};
    cycpp_shape_out_commod = std::vector<int>(rawcycpp_shape_out_commod, rawcycpp_shape_out_commod + 1);
    int rawcycpp_shape_out_buf_size[1] = {-1};
    cycpp_shape_out_buf_size = std::vector<int>(rawcycpp_shape_out_buf_size, rawcycpp_shape_out_buf_size + 1);
    int rawcycpp_shape_output[2] = {-1, -1};
    cycpp_shape_output = std::vector<int>(rawcycpp_shape_output, rawcycpp_shape_output + 2);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 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_streams", 0);
      cyclus::InfileTree* sub = bub;
      int n1 = sub->NMatches("stream");
      std::vector< std::pair< std::pair< double, double >, std::map< std::string, double > > > streams__val;
      streams__val.resize(n1);
      for (int i1 = 0; i1 < n1; ++i1) {
        std::pair< std::pair< double, double >, std::map< std::string, double > > elem;
        {
          cyclus::InfileTree* bub = sub->SubTree("stream", i1);
          cyclus::InfileTree* sub = bub;
            std::pair< double, double > firsti1;
            {
              cyclus::InfileTree* bub = sub->SubTree("info", 0);
              cyclus::InfileTree* sub = bub;
                double first0;
                {
                  double first0_in = cyclus::Query<double>(sub, "mixing_ratio", 0);
                  first0 = first0_in;
                }
                double second0;
                {
                  double second0_in = cyclus::Query<double>(sub, "buf_size", 0);
                  second0 = second0_in;
                }
              std::pair< double, double > firsti1_in(first0, second0);
              firsti1 = firsti1_in;
            }
            std::map< std::string, double > secondi1;
            {
              cyclus::InfileTree* bub = sub->SubTree("commodities", 0);
              cyclus::InfileTree* sub = bub;
              int n2 = sub->NMatches("item");
              std::map< std::string, double > secondi1_in;
              for (int i2 = 0; i2 < n2; ++i2) {
                std::string key;
                {
                  std::string key_in = cyclus::Query<std::string>(sub, "item/commodity", i2);
                  key = key_in;
                }
                double val;
                {
                  double val_in = cyclus::Query<double>(sub, "item/pref", i2);
                  val = val_in;
                }
                secondi1_in[key] = val;
              }
              secondi1 = secondi1_in;
            }
          std::pair< std::pair< double, double >, std::map< std::string, double > > elem_in(firsti1, secondi1);
          elem = elem_in;
        }
        streams__val[i1] = elem;
      }
      streams_ = streams__val;
    }
    {
      std::string out_commod_val = cyclus::Query<std::string>(sub, "out_commod");
      out_commod = out_commod_val;
    }
    if (sub->NMatches("out_buf_size") > 0) {
      {
        double out_buf_size_val = cyclus::Query<double>(sub, "out_buf_size");
        out_buf_size = out_buf_size_val;
      }
    } else {
      double out_buf_size_tmp = 1e+299;
      out_buf_size = out_buf_size_tmp;
    }
    if (sub->NMatches("throughput") > 0) {
      {
        double throughput_val = cyclus::Query<double>(sub, "throughput");
        throughput = throughput_val;
      }
    } else {
      double throughput_tmp = 1e+299;
      throughput = throughput_tmp;
    }
    if (sub->NMatches("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("streams_", streams_, &cycpp_shape_streams_)
    ->AddVal("out_commod", out_commod, &cycpp_shape_out_commod)
    ->AddVal("out_buf_size", out_buf_size, &cycpp_shape_out_buf_size)
    ->AddVal("throughput", throughput, &cycpp_shape_throughput)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
 
  virtual void InitFrom(cyclus::QueryableBackend* b) {
    cyclus::Facility::InitFrom(b);
    int rawcycpp_shape_streams_[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
    cycpp_shape_streams_ = std::vector<int>(rawcycpp_shape_streams_, rawcycpp_shape_streams_ + 8);
    int rawcycpp_shape_out_commod[1] = {-1};
    cycpp_shape_out_commod = std::vector<int>(rawcycpp_shape_out_commod, rawcycpp_shape_out_commod + 1);
    int rawcycpp_shape_out_buf_size[1] = {-1};
    cycpp_shape_out_buf_size = std::vector<int>(rawcycpp_shape_out_buf_size, rawcycpp_shape_out_buf_size + 1);
    int rawcycpp_shape_output[2] = {-1, -1};
    cycpp_shape_output = std::vector<int>(rawcycpp_shape_output, rawcycpp_shape_output + 2);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 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);
    streams_ = qr.GetVal<std::vector< std::pair< std::pair< double, double >, std::map< std::string, double > > > >("streams_");
    out_commod = qr.GetVal<std::string>("out_commod");
    out_buf_size = qr.GetVal<double>("out_buf_size");
    throughput = qr.GetVal<double>("throughput");
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
    output.capacity(out_buf_size);
  };
 
  virtual std::string schema() {
    return ""
      "<interleave>\n"
      "    <element name=\"in_streams\">\n"
      "        <oneOrMore>\n"
      "            <element name=\"stream\">\n"
      "                <interleave>\n"
      "                    <element name=\"info\">\n"
      "                        <interleave>\n"
      "                            <element name=\"mixing_ratio\">\n"
      "                                <data type=\"double\"/>\n"
      "                            </element>\n"
      "                            <element name=\"buf_size\">\n"
      "                                <data type=\"double\"/>\n"
      "                            </element>\n"
      "                        </interleave>\n"
      "                    </element>\n"
      "                    <element name=\"commodities\">\n"
      "                        <oneOrMore>\n"
      "                            <element name=\"item\">\n"
      "                                <interleave>\n"
      "                                    <element name=\"commodity\">\n"
      "                                        <data type=\"string\"/>\n"
      "                                    </element>\n"
      "                                    <element name=\"pref\">\n"
      "                                        <data type=\"double\"/>\n"
      "                                    </element>\n"
      "                                </interleave>\n"
      "                            </element>\n"
      "                        </oneOrMore>\n"
      "                    </element>\n"
      "                </interleave>\n"
      "            </element>\n"
      "        </oneOrMore>\n"
      "    </element>\n"
      "    <element name=\"out_commod\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"out_buf_size\">\n"
      "            <data type=\"double\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"throughput\">\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::Mixer\",\"entity\":\"facility\",\"par"
      "ents\":[\"cyclus::Facility\",\"cyclus::toolkit::Positi"
      "on\"],\"all_parents\":[\"cyclus::Agent\",\"cyclus::Facil"
      "ity\",\"cyclus::Ider\",\"cyclus::StateWrangler\",\"cyclu"
      "s::TimeListener\",\"cyclus::Trader\",\"cyclus::toolkit"
      "::Position\"],\"vars\":{\"streams_\":{\"alias\":[\"in_stre"
      "ams\",[\"stream\",[\"info\",\"mixing_ratio\",\"buf_size\"],"
      "[[\"commodities\",\"item\"],\"commodity\",\"pref\"]]],\"uit"
      "ype\":[\"oneormore\",[\"pair\",[\"pair\",\"double\",\"double"
      "\"],[\"oneormore\",\"incommodity\",\"double\"]]],\"uilabel"
      "\":[\"streams_\",[\"\",[\"\",\"\",\"\"],[[\"\",\"\"],\"\",\"\"]]],\"do"
      "c\":\"\",\"type\":[\"std::vector\",[\"std::pair\",[\"std::pa"
      "ir\",\"double\",\"double\"],[\"std::map\",\"std::string\",\""
      "double\"]]],\"index\":0,\"shape\":[-1,-1,-1,-1,-1,-1,-"
      "1,-"
      "1],\"tooltip\":[\"streams_\",[\"\",[\"\",\"\",\"\"],[[\"\",\"\"],\""
      "\",\"\"]]]},\"in_streams\":\"streams_\",\"out_commod\":{\"do"
      "c\":\"Commodity on which to offer/supply mixed fuel "
      "material.\",\"uilabel\":\"Output Commodity\",\"uitype\":\""
      "outcommodity\",\"type\":\"std::string\",\"index\":2,\"shap"
      "e\":[-"
      "1],\"alias\":\"out_commod\",\"tooltip\":\"out_commod\"},\"o"
      "ut_buf_size\":{\"doc\":\"Maximum amount of mixed "
      "material 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\":3,\"shap"
      "e\":[-"
      "1],\"alias\":\"out_buf_size\",\"tooltip\":\"out_buf_size\""
      "},\"output\":{\"capacity\":\"out_buf_size\",\"type\":[\"cyc"
      "lus::toolkit::ResBuf\",\"cyclus::Material\"],\"index\":"
      "4,\"shape\":[-1,-"
      "1]},\"throughput\":{\"default\":1e+299,\"doc\":\"Maximum "
      "number of kg of fuel material that can be mixed "
      "per time step.\",\"uilabel\":\"Maximum Throughput\",\"ui"
      "type\":\"range\",\"range\":[0.0,1e+299],\"units\":\"kg\",\"t"
      "ype\":\"double\",\"index\":5,\"shape\":[-"
      "1],\"alias\":\"throughput\",\"tooltip\":\"throughput\"},\"l"
      "atitude\":{\"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\":6,\"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\":7,\"shape\":[-"
      "1],\"alias\":\"longitude\",\"tooltip\":\"longitude\"}},\"ni"
      "che\":\"mixing facility\",\"doc\":\"Mixer mixes N "
      "streams with fixed, static, user-specified ratios "
      "into a single output stream. The Mixer has N input"
      " inventories: one for each streams to be mixed, "
      "and one output stream. The supplying of mixed "
      "material is constrained by  available inventory of"
      " mixed material quantities.\"}", root);
    if (!parsed_ok) {
      throw cyclus::ValueError("failed to parse annotations for cycamore::Mixer.");
    }
    return root;
  };
 
  virtual void Snapshot(cyclus::DbInit di) {
    di.NewDatum("Info")
    ->AddVal("streams_", streams_, &cycpp_shape_streams_)
    ->AddVal("out_commod", out_commod, &cycpp_shape_out_commod)
    ->AddVal("out_buf_size", out_buf_size, &cycpp_shape_out_buf_size)
    ->AddVal("throughput", throughput, &cycpp_shape_throughput)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
#line 53 "/cycamore/src/mixer.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);
 
 protected:
#pragma cyclus var {     "alias": ["in_streams", [ "stream", [ "info", "mixing_ratio", "buf_size"], [ "commodities", "commodity", "pref"]]],     "uitype": ["oneormore", [ "pair", ["pair", "double", "double"], ["oneormore", "incommodity", "double"]]],     "uilabel": "",     "doc": "",   }
#line 69 "/cycamore/src/mixer.h"
  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double> > > streams_;
  std::vector<int> cycpp_shape_streams_;
 
#line 70 "/cycamore/src/mixer.h"
 
  std::vector<std::map<std::string, double> > in_commods;
  std::vector<double> in_buf_sizes;
  std::vector<double> mixing_ratios;
 
  // custom SnapshotInv and InitInv and EnterNotify are used to persist this
  // state var.
  std::map<std::string, cyclus::toolkit::ResBuf<cyclus::Material> > streambufs;
 
 
#pragma cyclus var {                                                   "doc" : "Commodity on which to offer/supply mixed fuel material.",   "uilabel" : "Output Commodity", "uitype" : "outcommodity", }
#line 83 "/cycamore/src/mixer.h"
  std::string out_commod;
  std::vector<int> cycpp_shape_out_commod;
#line 84 "/cycamore/src/mixer.h"
 
 
#pragma cyclus var {     "doc" : "Maximum amount of mixed material 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 95 "/cycamore/src/mixer.h"
  double out_buf_size;
  std::vector<int> cycpp_shape_out_buf_size;
 
#line 96 "/cycamore/src/mixer.h"
 
#pragma cyclus var { "capacity" : "out_buf_size", }
  cyclus::toolkit::ResBuf<cyclus::Material> output;
  std::vector<int> cycpp_shape_output;
#line 99 "/cycamore/src/mixer.h"
 
 
#pragma cyclus var {     "default": CY_LARGE_DOUBLE,     "doc": "Maximum number of kg of fuel material that can be mixed per time step.",     "uilabel": "Maximum Throughput",     "uitype": "range",     "range": [0.0, CY_LARGE_DOUBLE],     "units": "kg",   }
#line 108 "/cycamore/src/mixer.h"
  double throughput;
  std::vector<int> cycpp_shape_throughput;
 
#line 109 "/cycamore/src/mixer.h"
 
  // intra-time-step state - no need to be a state var
  // map<request, inventory name>
  std::map<cyclus::Request<cyclus::Material>*, std::string> req_inventories_;
 
  cyclus::toolkit::MatlSellPolicy sell_policy;
 
  private:
  #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 124 "/cycamore/src/mixer.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 125 "/cycamore/src/mixer.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 132 "/cycamore/src/mixer.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
 
#line 133 "/cycamore/src/mixer.h"
 
  cyclus::toolkit::Position coordinates;
 
  void RecordPosition();
};
 
}  // namespace cycamore
 
#endif  // CYCAMORE_SRC_MIXER_H_