build/CommodConverter/commodconverter.cc

Go to the documentation of this file.

#line 1 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"
// commodconverter.cc
// Implements the CommodConverter class
#include "commodconverter.h"

namespace commodconverter {

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
CommodConverter::CommodConverter(cyclus::Context* ctx)
    : cyclus::Facility(ctx) {
  cyclus::Warn<cyclus::EXPERIMENTAL_WARNING>("the CommodConverter is experimental.");
    };

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// pragmas

std::string CommodConverter::schema() {
  return ""
    "<interleave>\n"
    "<element name=\"in_commod\">\n"
    "    <data type=\"string\" />\n"
    "</element>\n"
    "<element name=\"out_commod\">\n"
    "    <data type=\"string\" />\n"
    "</element>\n"
    "<optional>\n"
    "    <element name=\"in_recipe\">\n"
    "        <data type=\"string\" />\n"
    "    </element>\n"
    "</optional>\n"
    "<optional>\n"
    "    <element name=\"out_recipe\">\n"
    "        <data type=\"string\" />\n"
    "    </element>\n"
    "</optional>\n"
    "<optional>\n"
    "    <element name=\"process_time\">\n"
    "        <data type=\"int\" />\n"
    "    </element>\n"
    "</optional>\n"
    "<optional>\n"
    "    <element name=\"max_inv_size\">\n"
    "        <data type=\"double\" />\n"
    "    </element>\n"
    "</optional>\n"
    "</interleave>\n"
    ;
};
#line 17 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

Json::Value CommodConverter::annotations() {
  Json::Value root;
  Json::Reader reader;
  bool parsed_ok = reader.parse(
    "{\"vars\":{\"in_commod\":{\"doc\":\"commodity accepted by"
    " this "
    "facility\",\"type\":\"std::string\",\"tooltip\":\"input co"
    "mmodity\",\"index\":0},\"out_commod\":{\"doc\":\"commodity"
    " produced by this "
    "facility\",\"type\":\"std::string\",\"tooltip\":\"output c"
    "ommodity\",\"index\":1},\"in_recipe\":{\"default\":\"\",\"do"
    "c\":\"recipe accepted by this "
    "facility\",\"type\":\"std::string\",\"tooltip\":\"input re"
    "cipe\",\"index\":2},\"out_recipe\":{\"default\":\"\",\"doc\":"
    "\"recipe to be generated by this "
    "facility\",\"type\":\"std::string\",\"tooltip\":\"output r"
    "ecipe\",\"index\":3},\"process_time\":{\"default\":0,\"doc"
    "\":\"the time it takes to convert a received "
    "commodity "
    "(timesteps).\",\"type\":\"int\",\"tooltip\":\"process time"
    " (timesteps)\",\"index\":4},\"max_inv_size\":{\"default\""
    ":1e+299,\"doc\":\"the amount of material that can be "
    "in storage at one time "
    "(kg).\",\"type\":\"double\",\"tooltip\":\"maximum "
    "inventory size (kg)\",\"index\":5}},\"doc\":\"A "
    "commodconverter facility converts from one "
    "commodity to another, with an optional delay.\"}", root);
  if (!parsed_ok) {
    throw cyclus::ValueError("failed to parse annotations for commodconverter::CommodConverter.");
  }
  return root;
};
#line 19 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

void CommodConverter::InitInv(cyclus::Inventories& inv) {
};
#line 21 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

cyclus::Inventories CommodConverter::SnapshotInv() {
  cyclus::Inventories invs;
  return invs;
};
#line 23 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

void CommodConverter::InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
  cyclus::Facility::InfileToDb(tree, di);
  tree = tree->SubTree("config/*");
  cyclus::InfileTree* sub;
  int i;
  int n;
  in_commod = cyclus::Query<std::string>(tree, "in_commod");
  out_commod = cyclus::Query<std::string>(tree, "out_commod");
  in_recipe = cyclus::OptionalQuery<std::string>(tree, "in_recipe", "");
  out_recipe = cyclus::OptionalQuery<std::string>(tree, "out_recipe", "");
  process_time = cyclus::OptionalQuery<int>(tree, "process_time", 0);
  max_inv_size = cyclus::OptionalQuery<double>(tree, "max_inv_size", 1e+299);
  di.NewDatum("Info")
  ->AddVal("in_commod", in_commod)
  ->AddVal("out_commod", out_commod)
  ->AddVal("in_recipe", in_recipe)
  ->AddVal("out_recipe", out_recipe)
  ->AddVal("process_time", process_time)
  ->AddVal("max_inv_size", max_inv_size)
  ->Record();
};
#line 25 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

void CommodConverter::Snapshot(cyclus::DbInit di) {
  di.NewDatum("Info")
  ->AddVal("in_commod", in_commod)
  ->AddVal("out_commod", out_commod)
  ->AddVal("in_recipe", in_recipe)
  ->AddVal("out_recipe", out_recipe)
  ->AddVal("process_time", process_time)
  ->AddVal("max_inv_size", max_inv_size)
  ->Record();
};
#line 27 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

cyclus::Agent* CommodConverter::Clone() {
  commodconverter::CommodConverter* m = new commodconverter::CommodConverter(context());
  m->InitFrom(this);
  return m;
};
#line 29 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::InitFrom(CommodConverter* m) {    cyclus::Facility::InitFrom(m);
    in_commod = m->in_commod;
    out_commod = m->out_commod;
    in_recipe = m->in_recipe;
    out_recipe = m->out_recipe;
    process_time = m->process_time;
    max_inv_size = m->max_inv_size;
#line 34 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

  cyclus::toolkit::CommodityProducer::Copy(m);
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::InitFrom(cyclus::QueryableBackend* b){    cyclus::Facility::InitFrom(b);
    cyclus::QueryResult qr = b->Query("Info", NULL);
    in_commod = qr.GetVal<std::string>("in_commod");
    out_commod = qr.GetVal<std::string>("out_commod");
    in_recipe = qr.GetVal<std::string>("in_recipe");
    out_recipe = qr.GetVal<std::string>("out_recipe");
    process_time = qr.GetVal<int>("process_time");
    max_inv_size = qr.GetVal<double>("max_inv_size");
#line 42 "/Users/khuff/repos/cyclus/commodconverter/src/commodconverter.cc"

  using cyclus::toolkit::Commodity;
  Commodity commod = Commodity(out_commod);
  cyclus::toolkit::CommodityProducer::Add(commod);
  cyclus::toolkit::CommodityProducer::SetCapacity(commod, capacity);
  cyclus::toolkit::CommodityProducer::SetCost(commod, cost);
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::EnterNotify() {
  Facility::EnterNotify();

  using cyclus::toolkit::Commodity;
  Commodity commod = Commodity(out_commod);
  cyclus::toolkit::CommodityProducer::Add(commod);
  cyclus::toolkit::CommodityProducer::SetCapacity(commod, capacity);
  cyclus::toolkit::CommodityProducer::SetCost(commod, cost);
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::string CommodConverter::str() {
  std::stringstream ss;
  std::string ans;
  if (cyclus::toolkit::CommodityProducer::
      Produces(cyclus::toolkit::Commodity(out_commod_()))){
    ans = "yes";
  } else {
    ans = "no";
  }
  ss << cyclus::Facility::str();
  ss << " has facility parameters {" << "\n"
     << "     Input Commodity = " << in_commod_() << ",\n"
     << "     Output Commodity = " << out_commod_() << ",\n"
     << "     Process Time = " << process_time_() << ",\n"
     << "     Capacity = " << capacity_() << ",\n"
     << " commod producer members: " << " produces "
     << out_commod << "?:" << ans
     << " capacity: " << cyclus::toolkit::CommodityProducer::Capacity(out_commod_())
     << " cost: " << cyclus::toolkit::CommodityProducer::Cost(out_commod_())
     << "'}";
  return ss.str();
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::Tick() { 
  LOG(cyclus::LEV_INFO3, "ComCnv") << prototype() << " is ticking {";
  LOG(cyclus::LEV_INFO3, "ComCnv") << "}";
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::Tock() {
  LOG(cyclus::LEV_INFO3, "ComCnv") << prototype() << " is tocking {";
  while( processing[ready()].count() > 0 ) {
    Convert_(); // place processing into stocks
  }
  BeginProcessing_(); // place unprocessed inventory into processing
  LOG(cyclus::LEV_INFO3, "ComCnv") << "}";
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::set<cyclus::RequestPortfolio<cyclus::Material>::Ptr>
CommodConverter::GetMatlRequests() {
  using cyclus::CapacityConstraint;
  using cyclus::Material;
  using cyclus::RequestPortfolio;
  using cyclus::Request;

  std::set<RequestPortfolio<Material>::Ptr> ports;

  RequestPortfolio<Material>::Ptr port(new RequestPortfolio<Material>());
  Material::Ptr mat = Request_();
  double amt = mat->quantity();

  if (amt > cyclus::eps()) {
    //CapacityConstraint<Material> cc(amt);
    //port->AddConstraint(cc);

    port->AddRequest(mat, this, in_commod_());

    ports.insert(port);
  }

  return ports;
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::AcceptMatlTrades(
  const std::vector< std::pair<cyclus::Trade<cyclus::Material>,
  cyclus::Material::Ptr> >& responses) {
  std::vector< std::pair<cyclus::Trade<cyclus::Material>,
      cyclus::Material::Ptr> >::const_iterator it;
  for (it = responses.begin(); it != responses.end(); ++it) {
    AddMat_(it->second);
  }
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
std::set<cyclus::BidPortfolio<cyclus::Material>::Ptr>
CommodConverter::GetMatlBids(cyclus::CommodMap<cyclus::Material>::type&
                          commod_requests) {
  using cyclus::BidPortfolio;
  using cyclus::Material;

  std::set<BidPortfolio<Material>::Ptr> ports;

  std::set<std::string>::const_iterator it;
  BidPortfolio<Material>::Ptr port = GetBids_(commod_requests,
                                              out_commod,
                                              &stocks);
  if (!port->bids().empty()) {
    ports.insert(port);
  }

  return ports;

}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::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;

  // for each trade, respond
  std::vector< Trade<Material> >::const_iterator it;
  for (it = trades.begin(); it != trades.end(); ++it) {
    std::string commodity = it->request->commodity();
    double qty = it->amt;
    // create a material pointer representing what you can offer
    Material::Ptr response = TradeResponse_(qty, &stocks);

    responses.push_back(std::make_pair(*it, response));
    LOG(cyclus::LEV_INFO5, "ComCnv") << prototype()
                                  << " just received an order"
                                  << " for " << it->amt
                                  << " of " << commodity;
  }

}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::AddMat_(cyclus::Material::Ptr mat) {
  // Here we do not check that the recipe matches the input recipe. 

  LOG(cyclus::LEV_INFO5, "ComCnv") << prototype() << " is initially holding "
                                << inventory.quantity() << " total.";

  try {
    inventory.Push(mat);
  } catch (cyclus::Error& e) {
    e.msg(Agent::InformErrorMsg(e.msg()));
    throw e;
  }

  LOG(cyclus::LEV_INFO5, "ComCnv") << prototype() << " added " << mat->quantity()
                                << " of " << in_commod_()
                                << " to its inventory, which is holding "
                                << inventory.quantity() << " total.";

}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
cyclus::Material::Ptr CommodConverter::Request_() {
  double qty = std::max(0.0, current_capacity());
  LOG(cyclus::LEV_INFO5, "ComCnv") << prototype()
                                  << " just requested"
                                  << current_capacity()
                                  << " of commodity: " << in_commod
                                  << " with recipe: " << in_recipe;
  return cyclus::Material::CreateUntracked(qty,
                                        context()->GetRecipe(in_recipe));
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
cyclus::BidPortfolio<cyclus::Material>::Ptr CommodConverter::GetBids_(
    cyclus::CommodMap<cyclus::Material>::type& commod_requests,
    std::string commod,
    cyclus::toolkit::ResourceBuff* buffer) {
  using cyclus::Bid;
  using cyclus::BidPortfolio;
  using cyclus::CapacityConstraint;
  using cyclus::Composition;
  using cyclus::Converter;
  using cyclus::Material;
  using cyclus::Request;
  using cyclus::ResCast;
  using cyclus::toolkit::ResourceBuff;

  BidPortfolio<Material>::Ptr port(new BidPortfolio<Material>());

  if (commod_requests.count(commod) > 0 && buffer->quantity() > 0) {
    std::vector<Request<Material>*>& requests = commod_requests.at(commod);

    // get offer composition
    Material::Ptr back = ResCast<Material>(buffer->Pop(ResourceBuff::BACK));
    Composition::Ptr comp = back->comp();
    buffer->Push(back);

    std::vector<Request<Material>*>::iterator it;
    for (it = requests.begin(); it != requests.end(); ++it) {
      Request<Material>* req = *it;
      double qty = std::min(req->target()->quantity(), buffer->quantity());
      Material::Ptr offer = Material::CreateUntracked(qty, comp);
      port->AddBid(req, offer, this);
    }

    //CapacityConstraint<Material> cc(buffer->quantity());
    //port->AddConstraint(cc);
  }

  return port;
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
cyclus::Material::Ptr CommodConverter::TradeResponse_(
    double qty,
    cyclus::toolkit::ResourceBuff* buffer) {
  using cyclus::Material;
  using cyclus::ResCast;

  std::vector<Material::Ptr> manifest;
  try {
    // pop amount from inventory and blob it into one material
    manifest = ResCast<Material>(buffer->PopQty(qty));
  } catch(cyclus::Error& e) {
    e.msg(Agent::InformErrorMsg(e.msg()));
    throw e;
  }

  Material::Ptr response = manifest[0];
  crctx_.RemoveRsrc(response);
  for (int i = 1; i < manifest.size(); i++) {
    crctx_.RemoveRsrc(manifest[i]);
    response->Absorb(manifest[i]);
  }
  return response;
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::BeginProcessing_(){
  LOG(cyclus::LEV_DEBUG2, "ComCnv") << "CommodConverter " << prototype() 
                                    << " added resources to processing";
  if( inventory.count() > 0 ){
    try {
      processing[context()->time()].Push(inventory.Pop());
    } catch (cyclus::Error& e) {
      e.msg(Agent::InformErrorMsg(e.msg()));
      throw e;
    }
  }
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void CommodConverter::Convert_(){
  using cyclus::Material;
  using cyclus::ResCast;
  LOG(cyclus::LEV_DEBUG2, "ComCnv") << "CommodConverter " << prototype() 
                                    << " removed a resource from processing.";

  if ( processing.find(ready())->second.count() > 0 ) {
    try {
      // pop one material from processing 
      Material::Ptr mat = ResCast<Material>(processing.find(ready())->second.Pop());
      // if an out_recipe was provided, transmute it
      if( out_recipe != "" ){
        mat->Transmute(context()->GetRecipe(out_recipe));
      }
      // change its commod
      crctx_.UpdateRsrc(out_commod_(), mat);
      // put it in the stocks
      stocks.Push(mat);
    } catch (cyclus::Error& e) {
      e.msg(Agent::InformErrorMsg(e.msg()));
      throw e;
    }
  }
}


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
extern "C" cyclus::Agent* ConstructCommodConverter(cyclus::Context* ctx) {
  return new CommodConverter(ctx);
}

} // namespace commodconverter