build/cycamore/source.cc

Go to the documentation of this file.

 
#line 1 "/cycamore/src/source.cc"
#include "source.h"
 
#include <sstream>
#include <limits>
 
#include <boost/lexical_cast.hpp>
 
namespace cycamore {
 
Source::Source(cyclus::Context* ctx)
    : cyclus::Facility(ctx),
      throughput(std::numeric_limits<double>::max()),
      inventory_size(std::numeric_limits<double>::max()),
      package(cyclus::Package::unpackaged_name()),
      transport_unit(cyclus::TransportUnit::unrestricted_name()) {}
 
Source::~Source() {}
 
void Source::InitFrom(Source* 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_outcommod[1] = {-1};
    cycpp_shape_outcommod = std::vector<int>(rawcycpp_shape_outcommod, rawcycpp_shape_outcommod + 1);
    int rawcycpp_shape_outrecipe[1] = {-1};
    cycpp_shape_outrecipe = std::vector<int>(rawcycpp_shape_outrecipe, rawcycpp_shape_outrecipe + 1);
    int rawcycpp_shape_inventory_size[1] = {-1};
    cycpp_shape_inventory_size = std::vector<int>(rawcycpp_shape_inventory_size, rawcycpp_shape_inventory_size + 1);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_package[1] = {-1};
    cycpp_shape_package = std::vector<int>(rawcycpp_shape_package, rawcycpp_shape_package + 1);
    int rawcycpp_shape_transport_unit[1] = {-1};
    cycpp_shape_transport_unit = std::vector<int>(rawcycpp_shape_transport_unit, rawcycpp_shape_transport_unit + 1);
    int rawcycpp_shape_inventory[2] = {-1, -1};
    cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
    latitude = m->latitude;
    longitude = m->longitude;
    outcommod = m->outcommod;
    outrecipe = m->outrecipe;
    inventory_size = m->inventory_size;
    throughput = m->throughput;
    package = m->package;
    transport_unit = m->transport_unit;
    inventory.capacity(m->inventory.capacity());
#line 21 "/cycamore/src/source.cc"
  cyclus::toolkit::CommodityProducer::Copy(m);
}
 
void Source::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_outcommod[1] = {-1};
    cycpp_shape_outcommod = std::vector<int>(rawcycpp_shape_outcommod, rawcycpp_shape_outcommod + 1);
    int rawcycpp_shape_outrecipe[1] = {-1};
    cycpp_shape_outrecipe = std::vector<int>(rawcycpp_shape_outrecipe, rawcycpp_shape_outrecipe + 1);
    int rawcycpp_shape_inventory_size[1] = {-1};
    cycpp_shape_inventory_size = std::vector<int>(rawcycpp_shape_inventory_size, rawcycpp_shape_inventory_size + 1);
    int rawcycpp_shape_throughput[1] = {-1};
    cycpp_shape_throughput = std::vector<int>(rawcycpp_shape_throughput, rawcycpp_shape_throughput + 1);
    int rawcycpp_shape_package[1] = {-1};
    cycpp_shape_package = std::vector<int>(rawcycpp_shape_package, rawcycpp_shape_package + 1);
    int rawcycpp_shape_transport_unit[1] = {-1};
    cycpp_shape_transport_unit = std::vector<int>(rawcycpp_shape_transport_unit, rawcycpp_shape_transport_unit + 1);
    int rawcycpp_shape_inventory[2] = {-1, -1};
    cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
    cyclus::QueryResult qr = b->Query("Info", NULL);
    latitude = qr.GetVal<double>("latitude");
    longitude = qr.GetVal<double>("longitude");
    outcommod = qr.GetVal<std::string>("outcommod");
    outrecipe = qr.GetVal<std::string>("outrecipe");
    inventory_size = qr.GetVal<double>("inventory_size");
    throughput = qr.GetVal<double>("throughput");
    package = qr.GetVal<std::string>("package");
    transport_unit = qr.GetVal<std::string>("transport_unit");
    inventory.capacity(1e+300);
#line 26 "/cycamore/src/source.cc"
  namespace tk = cyclus::toolkit;
  tk::CommodityProducer::Add(tk::Commodity(outcommod),
                             tk::CommodInfo(throughput, throughput));
}
 
std::string Source::str() {
  namespace tk = cyclus::toolkit;
  std::stringstream ss;
  std::string ans;
  if (cyclus::toolkit::CommodityProducer::Produces(
          cyclus::toolkit::Commodity(outcommod))) {
    ans = "yes";
  } else {
    ans = "no";
  }
  ss << cyclus::Facility::str() << " supplies commodity '" << outcommod
     << "' with recipe '" << outrecipe << "' at a throughput of "
     << throughput << " kg per time step "
     << " commod producer members: "
     << " produces " << outcommod << "?: " << ans
     << " throughput: " << cyclus::toolkit::CommodityProducer::Capacity(outcommod)
     << " with package type: " << package
     << " and transport unit type: " << transport_unit
     << " cost: " << cyclus::toolkit::CommodityProducer::Cost(outcommod);
  return ss.str();
}
 
void Source::EnterNotify() {
  cyclus::Facility::EnterNotify();
  InitializePosition();
}
 
void Source::Build(cyclus::Agent* parent) {
  Facility::Build(parent);
 
  using cyclus::CompMap;
  using cyclus::Composition;
  using cyclus::Material;
 
  // create all source inventory and place into buf
  cyclus::Material::Ptr all_inv;
  Composition::Ptr blank_comp = Composition::CreateFromMass(CompMap());
  all_inv = (outrecipe.empty() || context() == NULL) ?           Material::Create(this, inventory_size, blank_comp) :           Material::Create(this, inventory_size, context()->GetRecipe(outrecipe));
#line 71 "/cycamore/src/source.cc"
  inventory.Push(all_inv);
 
}
 
std::set<cyclus::BidPortfolio<cyclus::Material>::Ptr> Source::GetMatlBids(
    cyclus::CommodMap<cyclus::Material>::type& commod_requests) {
  using cyclus::BidPortfolio;
  using cyclus::CapacityConstraint;
  using cyclus::Material;
  using cyclus::Package;
  using cyclus::Request;
  using cyclus::TransportUnit;
 
  double max_qty = std::min(throughput, inventory.quantity());
  cyclus::toolkit::RecordTimeSeries<double>("supply"+outcommod, this,
                                            max_qty);
  LOG(cyclus::LEV_INFO3, "Source") << prototype() << " is bidding up to "
                                   << max_qty << " kg of " << outcommod;
  LOG(cyclus::LEV_INFO5, "Source") << "stats: " << str();
 
  std::set<BidPortfolio<Material>::Ptr> ports;
  if (max_qty < cyclus::eps()) {
    return ports;
  } else if (commod_requests.count(outcommod) == 0) {
    return ports;
  }
 
  BidPortfolio<Material>::Ptr port(new BidPortfolio<Material>());
  std::vector<Request<Material>*>& requests = commod_requests[outcommod];
  std::vector<Request<Material>*>::iterator it;
  for (it = requests.begin(); it != requests.end(); ++it) {
    Request<Material>* req = *it;
    Material::Ptr target = req->target();
    double qty = std::min(target->quantity(), max_qty);
 
    // calculate packaging
    std::vector<double> bids = context()->GetPackage(package)->GetFillMass(qty);
 
    // calculate transport units
    int shippable_pkgs = context()->GetTransportUnit(transport_unit)
                         ->MaxShippablePackages(bids.size());
    if (shippable_pkgs < bids.size()) {
      bids.erase(bids.begin() + shippable_pkgs, bids.end());
    }
 
    std::vector<double>::iterator bit;
    for (bit = bids.begin(); bit != bids.end(); ++bit) {
      Material::Ptr m;
      m = outrecipe.empty() ?           Material::CreateUntracked(*bit, target->comp()) :           Material::CreateUntracked(*bit, context()->GetRecipe(outrecipe));
#line 122 "/cycamore/src/source.cc"
      port->AddBid(req, m, this);
    }
  }
 
  CapacityConstraint<Material> cc(max_qty);
  port->AddConstraint(cc);
  ports.insert(port);
  return ports;
}
 
void Source::GetMatlTrades(
    const std::vector<cyclus::Trade<cyclus::Material> >& trades,
    std::vector<std::pair<cyclus::Trade<cyclus::Material>,
                          cyclus::Material::Ptr> >& responses) {
  using cyclus::Material;
  using cyclus::Trade;
 
  int shippable_trades = context()->GetTransportUnit(transport_unit)
                         ->MaxShippablePackages(trades.size());
 
  std::vector<Trade<Material> >::const_iterator it;
  for (it = trades.begin(); it != trades.end(); ++it) {
    if (shippable_trades > 0) {
      double qty = it->amt;
 
      Material::Ptr m = inventory.Pop(qty);
      
      std::vector<Material::Ptr> m_pkgd = m->Package<Material>(context()->GetPackage(package));
 
      if (m->quantity() > cyclus::eps()) {
        // If not all material is packaged successfully, return the excess
        // amount to the inventory
        inventory.Push(m);
      }
 
      Material::Ptr response;
      if (m_pkgd.size() > 0) {
        // Because we responded (in GetMatlBids) with individual package-sized
        // bids, each packaged vector is guaranteed to have no more than one
        // package in it. This single packaged resource is our response
        response = m_pkgd[0];
        shippable_trades -= 1;
      } else {
        // If packaging failed, respond with a zero (empty) material
        response = Material::CreateUntracked(0, m->comp());
      }
 
      if (outrecipe.empty() && response->comp() != it->request->target()->comp()) {
        response->Transmute(it->request->target()->comp());
      }
 
      responses.push_back(std::make_pair(*it, response));
      LOG(cyclus::LEV_INFO5, "Source") << prototype() << " sent an order"
                                      << " for " << response->quantity() << " of " << outcommod;
    }
  }
}
 
extern "C" cyclus::Agent* ConstructSource(cyclus::Context* ctx) {
  return new Source(ctx);
}
 
}  // namespace cycamore