build/cycamore/conversion.cc

Go to the documentation of this file.

 
#line 1 "/cycamore/src/conversion.cc"
#include <algorithm>
#include <sstream>
 
#include <boost/lexical_cast.hpp>
#include "toolkit/mat_query.h"
 
#include "conversion.h"
 
using cyclus::RequestPortfolio;
using cyclus::BidPortfolio;
using cyclus::CommodMap;
using cyclus::Request;
using cyclus::Trade;
using cyclus::Material;
using cyclus::CapacityConstraint;
using cyclus::toolkit::ResBuf;
using cyclus::toolkit::RecordTimeSeries;
 
namespace cycamore {
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Conversion::Conversion(cyclus::Context* ctx)
    : cyclus::Facility(ctx) {
 
      // Make our Resource Buffers bulk buffers
      input = ResBuf<Material>(true);
      output = ResBuf<Material>(true);
    }
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Conversion::~Conversion() {}
std::string Conversion::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=\"incommods\">\n"
    "        <oneOrMore>\n"
    "            <element name=\"val\">\n"
    "                <data type=\"string\"/>\n"
    "            </element>\n"
    "        </oneOrMore>\n"
    "    </element>\n"
    "    <element name=\"outcommod\">\n"
    "        <a:documentation>Output commodity on which the conversion facility offers material.</a:documentation>\n"
    "        <data type=\"string\"/>\n"
    "    </element>\n"
    "    <optional>\n"
    "        <element name=\"throughput\">\n"
    "            <a:documentation>throughput the facility can convert at each time step</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "    <optional>\n"
    "        <element name=\"input_capacity\">\n"
    "            <a:documentation>Total capacity of the input buffer. The amount requested per time step is the minimum the conversion throughput and this capacity minus the amount of material in the input buffer.</a:documentation>\n"
    "            <data type=\"double\"/>\n"
    "        </element>\n"
    "    </optional>\n"
    "</interleave>\n";
};
#line 32 "/cycamore/src/conversion.cc"
 
Json::Value Conversion::annotations() {
  Json::Value root;
  Json::Reader reader;
  bool parsed_ok = reader.parse(
    "{\"name\":\"cycamore::Conversion\",\"entity\":\"facility\""
    ",\"parents\":[\"cyclus::Facility\",\"cyclus::toolkit::P"
    "osition\"],\"all_parents\":[\"EconomicEntity\",\"cyclus:"
    ":Agent\",\"cyclus::Facility\",\"cyclus::Ider\",\"cyclus:"
    ":StateWrangler\",\"cyclus::TimeListener\",\"cyclus::Tr"
    "ader\",\"cyclus::toolkit::Position\"],\"vars\":{\"latitu"
    "de\":{\"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\"},\"inc"
    "ommods\":{\"tooltip\":[\"input "
    "commodities\",\"\"],\"doc\":\"commodities that the "
    "conversion facility accepts\",\"uilabel\":[\"List of "
    "Input Commodities\",\"\"],\"uitype\":[\"oneormore\",\"inco"
    "mmodity\"],\"type\":[\"std::vector\",\"std::string\"],\"in"
    "dex\":2,\"shape\":[-1,-"
    "1],\"alias\":[\"incommods\",\"val\"]},\"outcommod\":{\"tool"
    "tip\":\"output commodity\",\"doc\":\"Output commodity on"
    " which the conversion facility offers "
    "material.\",\"uilabel\":\"Output Commodity\",\"uitype\":\""
    "outcommodity\",\"type\":\"std::string\",\"index\":3,\"shap"
    "e\":[-"
    "1],\"alias\":\"outcommod\"},\"throughput\":{\"default\":1e"
    "+299,\"tooltip\":\"conversion throughput per "
    "timestep\",\"uilabel\":\"Maximum conversion throughput"
    "\",\"uitype\":\"range\",\"range\":[0.0,1e+299],\"doc\":\"thr"
    "oughput the facility can convert at each time step"
    "\",\"type\":\"double\",\"index\":4,\"shape\":[-"
    "1],\"alias\":\"throughput\"},\"input_capacity\":{\"defaul"
    "t\":1e+299,\"tooltip\":\"input buffer "
    "capacity\",\"uilabel\":\"Maximum Storage of Input Buff"
    "er\",\"uitype\":\"range\",\"range\":[0.0,1e+299],\"doc\":\"T"
    "otal capacity of the input buffer. The amount "
    "requested per time step is the minimum the "
    "conversion throughput and this capacity minus the "
    "amount of material in the input buffer.\",\"type\":\"d"
    "ouble\",\"index\":5,\"shape\":[-"
    "1],\"alias\":\"input_capacity\"},\"input\":{\"capacity\":\""
    "input_capacity\",\"type\":[\"cyclus::toolkit::ResBuf\","
    "\"cyclus::Material\"],\"index\":6,\"shape\":[-1,-"
    "1]}},\"doc\":\" A conversion facility that accepts "
    "materials and products and with a \\n fixed "
    "throughput (per time step) converts them into its "
    "outcommod. \"}", root);
  if (!parsed_ok) {
    throw cyclus::ValueError("failed to parse annotations for cycamore::Conversion.");
  }
  return root;
};
 
void Conversion::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_incommods[2] = {-1, -1};
  cycpp_shape_incommods = std::vector<int>(rawcycpp_shape_incommods, rawcycpp_shape_incommods + 2);
  int rawcycpp_shape_outcommod[1] = {-1};
  cycpp_shape_outcommod = std::vector<int>(rawcycpp_shape_outcommod, rawcycpp_shape_outcommod + 1);
  int rawcycpp_shape_throughput[1] = {-1};
  cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
  int rawcycpp_shape_input_capacity[1] = {-1};
  cycpp_shape_input_capacity = std::vector<int>(rawcycpp_shape_input_capacity, rawcycpp_shape_input_capacity + 1);
  int rawcycpp_shape_input[2] = {-1, -1};
  cycpp_shape_input = std::vector<int>(rawcycpp_shape_input, rawcycpp_shape_input + 2);
  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("incommods", 0);
    cyclus::InfileTree* sub = bub;
    int n1 = sub->NMatches("val");
    std::vector< std::string > incommods_val;
    incommods_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;
      }
      incommods_val[i1] = elem;
    }
    incommods = incommods_val;
  }
  {
    std::string outcommod_val = cyclus::Query<std::string>(sub, "outcommod");
    outcommod = outcommod_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("input_capacity") > 0) {
    {
      double input_capacity_val = cyclus::Query<double>(sub, "input_capacity");
      input_capacity = input_capacity_val;
    }
  } else {
    double input_capacity_tmp = 1e+299;
    input_capacity = input_capacity_tmp;
  }
  di.NewDatum("Info")
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->AddVal("incommods", incommods, &cycpp_shape_incommods)
  ->AddVal("outcommod", outcommod, &cycpp_shape_outcommod)
  ->AddVal("throughput", throughput, &cycpp_shape_throughput)
  ->AddVal("input_capacity", input_capacity, &cycpp_shape_input_capacity)
  ->Record();
};
 
void Conversion::Snapshot(cyclus::DbInit di) {
  di.NewDatum("Info")
  ->AddVal("latitude", latitude, &cycpp_shape_latitude)
  ->AddVal("longitude", longitude, &cycpp_shape_longitude)
  ->AddVal("incommods", incommods, &cycpp_shape_incommods)
  ->AddVal("outcommod", outcommod, &cycpp_shape_outcommod)
  ->AddVal("throughput", throughput, &cycpp_shape_throughput)
  ->AddVal("input_capacity", input_capacity, &cycpp_shape_input_capacity)
  ->Record();
};
 
cyclus::Inventories Conversion::SnapshotInv() {
  cyclus::Inventories invs;
  invs["input"] = input.PopNRes(input.count());
  input.Push(invs["input"]);
  return invs;
};
 
void Conversion::InitInv(cyclus::Inventories& inv) {
  input.Push(inv["input"]);
  
};
 
cyclus::Agent* Conversion::Clone() {
  cycamore::Conversion* m = new cycamore::Conversion(context());
  m->InitFrom(this);
  return m;
};
 
void Conversion::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_incommods[2] = {-1, -1};
  cycpp_shape_incommods = std::vector<int>(rawcycpp_shape_incommods, rawcycpp_shape_incommods + 2);
  int rawcycpp_shape_outcommod[1] = {-1};
  cycpp_shape_outcommod = std::vector<int>(rawcycpp_shape_outcommod, rawcycpp_shape_outcommod + 1);
  int rawcycpp_shape_throughput[1] = {-1};
  cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
  int rawcycpp_shape_input_capacity[1] = {-1};
  cycpp_shape_input_capacity = std::vector<int>(rawcycpp_shape_input_capacity, rawcycpp_shape_input_capacity + 1);
  int rawcycpp_shape_input[2] = {-1, -1};
  cycpp_shape_input = std::vector<int>(rawcycpp_shape_input, rawcycpp_shape_input + 2);
  cyclus::QueryResult qr = b->Query("Info", NULL);
  latitude = qr.GetVal<double>("latitude");
  longitude = qr.GetVal<double>("longitude");
  incommods = qr.GetVal<std::vector< std::string > >("incommods");
  outcommod = qr.GetVal<std::string>("outcommod");
  throughput = qr.GetVal<double>("throughput");
  input_capacity = qr.GetVal<double>("input_capacity");
  input.capacity(input_capacity);
};
 
void Conversion::InitFrom(cycamore::Conversion* 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_incommods[2] = {-1, -1};
  cycpp_shape_incommods = std::vector<int>(rawcycpp_shape_incommods, rawcycpp_shape_incommods + 2);
  int rawcycpp_shape_outcommod[1] = {-1};
  cycpp_shape_outcommod = std::vector<int>(rawcycpp_shape_outcommod, rawcycpp_shape_outcommod + 1);
  int rawcycpp_shape_throughput[1] = {-1};
  cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
  int rawcycpp_shape_input_capacity[1] = {-1};
  cycpp_shape_input_capacity = std::vector<int>(rawcycpp_shape_input_capacity, rawcycpp_shape_input_capacity + 1);
  int rawcycpp_shape_input[2] = {-1, -1};
  cycpp_shape_input = std::vector<int>(rawcycpp_shape_input, rawcycpp_shape_input + 2);
  latitude = m->latitude;
  longitude = m->longitude;
  incommods = m->incommods;
  outcommod = m->outcommod;
  throughput = m->throughput;
  input_capacity = m->input_capacity;
  input.capacity(m->input.capacity());
};
#line 42 "/cycamore/src/conversion.cc"
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Conversion::EnterNotify() {
  cyclus::Facility::EnterNotify();
  InitializePosition();
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::string Conversion::str() {
  using std::string;
  using std::vector;
  std::stringstream ss;
  ss << cyclus::Facility::str();
 
  string msg = "";
  msg += "accepts commodities ";
  for (vector<string>::iterator commod = incommods.begin();
       commod != incommods.end();
       commod++) {
    msg += (commod == incommods.begin() ? "{" : ", ");
    msg += (*commod);
  }
  msg += "} until its input is full at ";
  msg += std::to_string(input.capacity());
  msg += " kg.";
 
  msg += "} and converts ";
  msg += std::to_string(throughput);
  msg += " kg/timestep into commodity ";
  ss << msg << outcommod;
  return "" + ss.str();
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Conversion::Tick() {
  Convert();
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Conversion::Tock() {}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
double Conversion::AvailableFeedstockCapacity() {
  return input.capacity() - input.quantity();
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Conversion::Convert() {
  if (input.quantity() > 0) {
    output.Push(input.Pop(std::min(input.quantity(), throughput)));
  }
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::set<RequestPortfolio<Material>::Ptr> Conversion::GetMatlRequests() {
  std::set<RequestPortfolio<Material>::Ptr> ports;
 
  // Check if we need material
  double available_capacity = AvailableFeedstockCapacity();
  if (available_capacity <= 0) return ports;
 
  // Create request portfolio
  RequestPortfolio<Material>::Ptr port(new RequestPortfolio<Material>());
 
  // Create material request with no recipe
  Material::Ptr mat = cyclus::NewBlankMaterial(available_capacity);
 
 
  // Add request for all commodities using default preference
  for (std::vector<std::string>::iterator it = incommods.begin();
       it != incommods.end(); ++it) {
    Request<Material>* req = port->AddRequest(mat, this, *it);
  }
 
  // Add capacity constraint to ensure we never get more feed than capacity
  CapacityConstraint<Material> cc(available_capacity);
  port->AddConstraint(cc);
 
  ports.insert(port);
  return ports;
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::set<BidPortfolio<Material>::Ptr> Conversion::GetMatlBids(
  CommodMap<Material>::type& commod_requests) {
  std::set<BidPortfolio<Material>::Ptr> ports;
 
  // Check if we have material to offer
  if (output.quantity() <= 0) return ports;
 
  // Create bid portfolio
  BidPortfolio<Material>::Ptr port(new BidPortfolio<Material>());
 
  // Respond to requests for our commodity
  std::vector<Request<Material>*>& requests = commod_requests[outcommod];
  for (std::vector<Request<Material>*>::iterator it = requests.begin();
      it != requests.end(); ++it) {
 
    double available = output.quantity();
    double requested = (*it)->target()->quantity();
    double offer_qty = std::min(available, requested);
 
    if (offer_qty > 0) {
      Material::Ptr offer = Material::CreateUntracked(offer_qty, output.Peek()->comp());
      port->AddBid(*it, offer, this);  // Note: *it, not **it
    }
  }
 
  // Add capacity constraint so we never give out more than we have
  CapacityConstraint<Material> cc(output.quantity());
  port->AddConstraint(cc);
 
  ports.insert(port);
  return ports;
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Conversion::AcceptMatlTrades(
  const std::vector<std::pair<Trade<Material>, Material::Ptr>>& responses) {
 
  for (std::vector<std::pair<Trade<Material>, Material::Ptr>>::const_iterator it =
      responses.begin(); it != responses.end(); ++it) {
 
 
    // Add material to the input buffer
    input.Push(it->second);
    
  }
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void Conversion::GetMatlTrades(
  const std::vector<Trade<Material>>& trades,
  std::vector<std::pair<Trade<Material>, Material::Ptr>>& responses) {
 
  for (std::vector<Trade<Material>>::const_iterator it = trades.begin();
      it != trades.end(); ++it) {
 
    Material::Ptr response = output.Pop(it->amt);
 
    responses.push_back(std::make_pair(*it, response));
  }
}
 
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
extern "C" cyclus::Agent* ConstructConversion(cyclus::Context* ctx) {
  return new Conversion(ctx);
}
 
}  // namespace cycamore