build/cycamore/source.h

Go to the documentation of this file.

 
#line 1 "/cycamore/src/source.h"
#ifndef CYCAMORE_SRC_SOURCE_H_
#define CYCAMORE_SRC_SOURCE_H_
 
#include <set>
#include <vector>
 
#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 {
 
class Context;
 
class Source : public cyclus::Facility,
  public cyclus::toolkit::CommodityProducer,
  public cyclus::toolkit::Position {
  friend class SourceTest;
 public:
 
  Source(cyclus::Context* ctx);
 
  virtual ~Source();
 
  virtual std::string version() { return CYCAMORE_VERSION; }
 
  #pragma cyclus note {     "doc": "This facility acts as a source of material with a fixed throughput (per\n"            "time step) capacity and a lifetime capacity defined by a total inventory\n"            "size.  It offers its material as a single commodity. If a composition\n"            "recipe is specified, it provides that single material composition to\n"            "requesters.  If unspecified, the source provides materials with the exact\n"            "requested compositions.  The inventory size and throughput both default to\n"            "infinite.  Supplies material results in corresponding decrease in\n"            "inventory, and when the inventory size reaches zero, the source can provide\n"            "no more material.\n"            "",   }
#line 49 "/cycamore/src/source.h"
 
  virtual cyclus::Agent* Clone() {
    cycamore::Source* m = new cycamore::Source(context());
    m->InitFrom(this);
    return m;
  };
 
  virtual std::string schema() {
    return ""
      "<interleave>\n"
      "    <element name=\"outcommod\">\n"
      "        <data type=\"string\"/>\n"
      "    </element>\n"
      "    <optional>\n"
      "        <element name=\"outrecipe\">\n"
      "            <data type=\"string\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"inventory_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=\"package\">\n"
      "            <data type=\"string\"/>\n"
      "        </element>\n"
      "    </optional>\n"
      "    <optional>\n"
      "        <element name=\"transport_unit\">\n"
      "            <data type=\"string\"/>\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::Source\",\"entity\":\"facility\",\"pa"
      "rents\":[\"cyclus::Facility\",\"cyclus::toolkit::Commo"
      "dityProducer\",\"cyclus::toolkit::Position\"],\"all_pa"
      "rents\":[\"cyclus::Agent\",\"cyclus::Facility\",\"cyclus"
      "::Ider\",\"cyclus::StateWrangler\",\"cyclus::TimeListe"
      "ner\",\"cyclus::Trader\",\"cyclus::toolkit::AgentManag"
      "ed\",\"cyclus::toolkit::CommodityProducer\",\"cyclus::"
      "toolkit::Position\"],\"vars\":{\"outcommod\":{\"tooltip\""
      ":\"source output commodity\",\"doc\":\"Output commodity"
      " on which the source offers "
      "material.\",\"uilabel\":\"Output Commodity\",\"uitype\":\""
      "outcommodity\",\"type\":\"std::string\",\"index\":0,\"shap"
      "e\":[-"
      "1],\"alias\":\"outcommod\"},\"outrecipe\":{\"tooltip\":\"na"
      "me of material recipe to provide\",\"doc\":\"Name of "
      "composition recipe that this source provides "
      "regardless of requested composition. If empty, "
      "source creates and provides whatever compositions "
      "are requested.\",\"uilabel\":\"Output Recipe\",\"default"
      "\":\"\",\"uitype\":\"outrecipe\",\"type\":\"std::string\",\"in"
      "dex\":1,\"shape\":[-"
      "1],\"alias\":\"outrecipe\"},\"inventory_size\":{\"doc\":\"T"
      "otal amount of material this source has remaining."
      " Every trade decreases this value by the supplied "
      "material quantity.  When it reaches zero, the "
      "source cannot provide any  more material.\",\"defaul"
      "t\":1e+299,\"uitype\":\"range\",\"range\":[0.0,1e+299],\"u"
      "ilabel\":\"Initial Inventory\",\"units\":\"kg\",\"type\":\"d"
      "ouble\",\"index\":2,\"shape\":[-"
      "1],\"alias\":\"inventory_size\",\"tooltip\":\"inventory_s"
      "ize\"},\"throughput\":{\"default\":1e+299,\"tooltip\":\"pe"
      "r time step throughput\",\"units\":\"kg/(time "
      "step)\",\"uilabel\":\"Maximum Throughput\",\"uitype\":\"ra"
      "nge\",\"range\":[0.0,1e+299],\"doc\":\"amount of "
      "commodity that can be supplied at each time step\","
      "\"type\":\"double\",\"index\":3,\"shape\":[-"
      "1],\"alias\":\"throughput\"},\"package\":{\"default\":\"unp"
      "ackaged\",\"tooltip\":\"name of package to provide "
      "material in\",\"doc\":\"Name of package that this "
      "source provides. Offers will only bemade in "
      "packagable quantities of "
      "material.\",\"uilabel\":\"Output Package Type\",\"uitype"
      "\":\"package\",\"type\":\"std::string\",\"index\":4,\"shape\""
      ":[-"
      "1],\"alias\":\"package\"},\"transport_unit\":{\"default\":"
      "\"unrestricted\",\"tooltip\":\"name of transport unit "
      "to ship packages in\",\"doc\":\"Name of transport unit"
      " that this source uses to ship packages of "
      "material. Offers will only be made in shippable "
      "quantities of packages. Optional if packaging is "
      "used, but use of transport units requires "
      "packaging type to also be set\",\"uilabel\":\"Output "
      "Transport Unit Type\",\"uitype\":\"transportunit\",\"typ"
      "e\":\"std::string\",\"index\":5,\"shape\":[-"
      "1],\"alias\":\"transport_unit\"},\"latitude\":{\"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\"},\"inv"
      "entory\":{\"tooltip\":\"Material buffer\",\"type\":[\"cycl"
      "us::toolkit::ResBuf\",\"cyclus::Material\"],\"index\":8"
      ",\"shape\":[-1,-1]}},\"doc\":\"This facility acts as a "
      "source of material with a fixed throughput "
      "(per\\ntime step) capacity and a lifetime capacity "
      "defined by a total inventory\\nsize.  It offers its"
      " material as a single commodity. If a "
      "composition\\nrecipe is specified, it provides that"
      " single material composition to\\nrequesters.  If "
      "unspecified, the source provides materials with "
      "the exact\\nrequested compositions.  The inventory "
      "size and throughput both default to\\ninfinite.  "
      "Supplies material results in corresponding "
      "decrease in\\ninventory, and when the inventory "
      "size reaches zero, the source can provide\\nno more"
      " material.\\n\"}", root);
    if (!parsed_ok) {
      throw cyclus::ValueError("failed to parse annotations for cycamore::Source.");
    }
    return root;
  };
 
  virtual void InfileToDb(cyclus::InfileTree* tree, cyclus::DbInit di) {
    cyclus::Facility::InfileToDb(tree, di);
    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_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_inventory[2] = {-1, -1};
    cycpp_shape_inventory = std::vector<int>(rawcycpp_shape_inventory, rawcycpp_shape_inventory + 2);
    cyclus::InfileTree* sub = tree->SubTree("config/*");
    int i;
    int n;
    {
      std::string outcommod_val = cyclus::Query<std::string>(sub, "outcommod");
      outcommod = outcommod_val;
    }
    if (sub->NMatches("outrecipe") > 0) {
      {
        std::string outrecipe_val = cyclus::Query<std::string>(sub, "outrecipe");
        outrecipe = outrecipe_val;
      }
    } else {
      std::string outrecipe_tmp("");
      outrecipe = outrecipe_tmp;
    }
    if (sub->NMatches("inventory_size") > 0) {
      {
        double inventory_size_val = cyclus::Query<double>(sub, "inventory_size");
        inventory_size = inventory_size_val;
      }
    } else {
      double inventory_size_tmp = 1e+299;
      inventory_size = inventory_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("package") > 0) {
      {
        std::string package_val = cyclus::Query<std::string>(sub, "package");
        package = package_val;
      }
    } else {
      std::string package_tmp("unpackaged");
      package = package_tmp;
    }
    if (sub->NMatches("transport_unit") > 0) {
      {
        std::string transport_unit_val = cyclus::Query<std::string>(sub, "transport_unit");
        transport_unit = transport_unit_val;
      }
    } else {
      std::string transport_unit_tmp("unrestricted");
      transport_unit = transport_unit_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("outcommod", outcommod, &cycpp_shape_outcommod)
    ->AddVal("outrecipe", outrecipe, &cycpp_shape_outrecipe)
    ->AddVal("inventory_size", inventory_size, &cycpp_shape_inventory_size)
    ->AddVal("throughput", throughput, &cycpp_shape_throughput)
    ->AddVal("package", package, &cycpp_shape_package)
    ->AddVal("transport_unit", transport_unit, &cycpp_shape_transport_unit)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
 
  virtual void Snapshot(cyclus::DbInit di) {
    di.NewDatum("Info")
    ->AddVal("outcommod", outcommod, &cycpp_shape_outcommod)
    ->AddVal("outrecipe", outrecipe, &cycpp_shape_outrecipe)
    ->AddVal("inventory_size", inventory_size, &cycpp_shape_inventory_size)
    ->AddVal("throughput", throughput, &cycpp_shape_throughput)
    ->AddVal("package", package, &cycpp_shape_package)
    ->AddVal("transport_unit", transport_unit, &cycpp_shape_transport_unit)
    ->AddVal("latitude", latitude, &cycpp_shape_latitude)
    ->AddVal("longitude", longitude, &cycpp_shape_longitude)
    ->Record();
  };
 
  virtual cyclus::Inventories SnapshotInv() {
    cyclus::Inventories invs;
    invs["inventory"] = inventory.PopNRes(inventory.count());
    inventory.Push(invs["inventory"]);
    return invs;
  };
 
  virtual void InitInv(cyclus::Inventories& inv) {
    inventory.Push(inv["inventory"]);
    
  };
#line 57 "/cycamore/src/source.h"
 
  virtual void InitFrom(Source* m);
 
  virtual void InitFrom(cyclus::QueryableBackend* b);
 
  virtual void Tick() {};
 
  virtual void Tock() {};
 
  virtual std::string str();
 
  virtual std::set<cyclus::BidPortfolio<cyclus::Material>::Ptr>
      GetMatlBids(cyclus::CommodMap<cyclus::Material>::type&
                  commod_requests);
 
  virtual void EnterNotify();
 
  virtual void Build(cyclus::Agent* parent);
 
  virtual void GetMatlTrades(
    const std::vector< cyclus::Trade<cyclus::Material> >& trades,
    std::vector<std::pair<cyclus::Trade<cyclus::Material>,
    cyclus::Material::Ptr> >& responses);
 
 private:
  #pragma cyclus var {     "tooltip": "source output commodity",     "doc": "Output commodity on which the source offers material.",     "uilabel": "Output Commodity",     "uitype": "outcommodity",   }
#line 90 "/cycamore/src/source.h"
  std::string outcommod;
  std::vector<int> cycpp_shape_outcommod;
#line 91 "/cycamore/src/source.h"
 
 
  #pragma cyclus var {     "tooltip": "name of material recipe to provide",     "doc": "Name of composition recipe that this source provides regardless "            "of requested composition. If empty, source creates and provides "            "whatever compositions are requested.",     "uilabel": "Output Recipe",     "default": "",     "uitype": "outrecipe",   }
#line 101 "/cycamore/src/source.h"
  std::string outrecipe;
  std::vector<int> cycpp_shape_outrecipe;
#line 102 "/cycamore/src/source.h"
 
 
  #pragma cyclus var {     "doc": "Total amount of material this source has remaining."            " Every trade decreases this value by the supplied material "            "quantity.  When it reaches zero, the source cannot provide any "            " more material.",     "default": CY_LARGE_DOUBLE,     "uitype": "range",     "range": [0.0, CY_LARGE_DOUBLE],     "uilabel": "Initial Inventory",     "units": "kg",   }
#line 114 "/cycamore/src/source.h"
  double inventory_size;
  std::vector<int> cycpp_shape_inventory_size;
#line 115 "/cycamore/src/source.h"
 
 
  #pragma cyclus var {      "default": CY_LARGE_DOUBLE,     "tooltip": "per time step throughput",     "units": "kg/(time step)",     "uilabel": "Maximum Throughput",     "uitype": "range",     "range": [0.0, CY_LARGE_DOUBLE],     "doc": "amount of commodity that can be supplied at each time step",   }
#line 125 "/cycamore/src/source.h"
  double throughput;
  std::vector<int> cycpp_shape_throughput;
#line 126 "/cycamore/src/source.h"
 
 
  #pragma cyclus var {     "default": "unpackaged",     "tooltip": "name of package to provide material in",     "doc": "Name of package that this source provides. Offers will only be"            "made in packagable quantities of material.",     "uilabel": "Output Package Type",     "uitype": "package",   }
#line 135 "/cycamore/src/source.h"
  std::string package;
  std::vector<int> cycpp_shape_package;
#line 136 "/cycamore/src/source.h"
 
 
  #pragma cyclus var {     "default": "unrestricted",     "tooltip": "name of transport unit to ship packages in",     "doc": "Name of transport unit that this source uses to ship packages of "            "material. Offers will only be made in shippable quantities of "            "packages. Optional if packaging is used, but use of transport "            "units requires packaging type to also be set",     "uilabel": "Output Transport Unit Type",     "uitype": "transportunit",   }
#line 147 "/cycamore/src/source.h"
  std::string transport_unit;
  std::vector<int> cycpp_shape_transport_unit;
#line 148 "/cycamore/src/source.h"
 
 
  #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 155 "/cycamore/src/source.h"
  double latitude;
  std::vector<int> cycpp_shape_latitude;
#line 156 "/cycamore/src/source.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 163 "/cycamore/src/source.h"
  double longitude;
  std::vector<int> cycpp_shape_longitude;
#line 164 "/cycamore/src/source.h"
 
 
  #pragma cyclus var {     "tooltip":"Material buffer"}
#line 167 "/cycamore/src/source.h"
  cyclus::toolkit::ResBuf<cyclus::Material> inventory;
  std::vector<int> cycpp_shape_inventory;
 
#line 168 "/cycamore/src/source.h"
 
  cyclus::toolkit::Position coordinates;
 
  void RecordPosition();
  void SetPackage();
};
 
}  // namespace cycamore
 
#endif  // CYCAMORE_SRC_SOURCE_H_